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-IEs.hpp"
24 #include "X2AP-Containers.hpp"
25 #include "X2AP-Constants.hpp"
28 ActivatedCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33 struct ActivatedCellList_Item_ExtIEs
35 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
37 size_t get_index() const {return type;}
38 bool is_unknown() const { return type == 1; }
39 void clear() {type = 0;}
40 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
41 template<typename V> bool decode(V& v)
44 if(!v(ref_nested())) return false;
45 { type = 1; return true;}
49 template<typename V> bool encode(V& v) const
51 return v(ref_nested());
55 template<typename V> bool decode(size_t index, V& v)
60 case 1: type = 1; return v(ref_nested());
66 template<typename V> bool encode(size_t index, V& v) const
68 if(index != type) {return false;} return v(ref_nested());
75 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
77 size_t get_index() const {return type;}
78 bool is_unknown() const { return type == 1; }
79 void clear() {type = 0;}
80 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
81 template<typename V> bool decode(V& v)
84 if(!v(ref_nested())) return false;
85 { type = 1; return true;}
89 template<typename V> bool encode(V& v) const
91 return v(ref_nested());
95 template<typename V> bool decode(size_t index, V& v)
100 case 1: type = 1; return v(ref_nested());
101 ref_nested().clear();
106 template<typename V> bool encode(size_t index, V& v) const
108 if(index != type) {return false;} return v(ref_nested());
115 struct Extension_t : asn::typefield<true>
117 ~Extension_t() {clear();}
118 size_t get_index() const {return type;}
119 bool is_unknown() const { return type == 1; }
122 type = 0; ref_nested().clear();
124 template<typename V> static inline void enumerate(V& v)
129 template<typename V> bool decode(size_t index, V& v)
134 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
139 template<typename V> bool encode(size_t index, V& v) const
141 if(index != type) return false;
149 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
151 size_t get_index() const {return type;}
152 bool is_unknown() const { return type == 1; }
153 void clear() {type = 0;}
154 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
155 template<typename V> bool decode(V& v)
158 if(!v(ref_nested())) return false;
159 { type = 1; return true;}
163 template<typename V> bool encode(V& v) const
165 return v(ref_nested());
169 template<typename V> bool decode(size_t index, V& v)
174 case 1: type = 1; return v(ref_nested());
175 ref_nested().clear();
180 template<typename V> bool encode(size_t index, V& v) const
182 if(index != type) {return false;} return v(ref_nested());
192 ActivatedCellList-Item::= SEQUENCE {
194 iE-Extensions ProtocolExtensionContainer { {ActivatedCellList-Item-ExtIEs} } OPTIONAL,
199 struct ActivatedCellList_Item : asn::sequence<2, 0, true, 1>
201 static constexpr const char* name() {return "ActivatedCellList-Item";}
202 using parent_t = asn::sequence<2, 0, true, 1>;
205 static constexpr const char* name() {return "ecgi_t";}
206 using parent_t = ECGI;
209 ecgi_t& ref_ecgi() {return ecgi;}
210 ecgi_t const& ref_ecgi() const {return ecgi;}
211 struct iE_Extensions_t : ProtocolExtensionContainer<ActivatedCellList_Item_ExtIEs>
213 static constexpr const char* name() {return "iE_Extensions_t";}
214 using parent_t = ProtocolExtensionContainer<ActivatedCellList_Item_ExtIEs>;
215 static constexpr bool optional = true;
218 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
219 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
220 template<typename V> void decode(V& v)
226 template<typename V> void encode(V& v) const
235 iE_Extensions.clear();
240 iE_Extensions_t iE_Extensions;
244 ActivatedCellList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ActivatedCellList-Item
247 struct ActivatedCellList_elm : ActivatedCellList_Item
249 static constexpr const char* name() {return "ActivatedCellList_elm";}
250 using parent_t = ActivatedCellList_Item;
253 struct ActivatedCellList : asn::sequenceof<ActivatedCellList_elm>
255 static constexpr const char* name() {return "ActivatedCellList";}
256 using parent_t = asn::sequenceof<ActivatedCellList_elm>;
257 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
261 ActivatedNRCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
266 struct ActivatedNRCellList_Item_ExtIEs
268 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
270 size_t get_index() const {return type;}
271 bool is_unknown() const { return type == 1; }
272 void clear() {type = 0;}
273 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
274 template<typename V> bool decode(V& v)
277 if(!v(ref_nested())) return false;
278 { type = 1; return true;}
282 template<typename V> bool encode(V& v) const
284 return v(ref_nested());
288 template<typename V> bool decode(size_t index, V& v)
293 case 1: type = 1; return v(ref_nested());
294 ref_nested().clear();
299 template<typename V> bool encode(size_t index, V& v) const
301 if(index != type) {return false;} return v(ref_nested());
308 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
310 size_t get_index() const {return type;}
311 bool is_unknown() const { return type == 1; }
312 void clear() {type = 0;}
313 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
314 template<typename V> bool decode(V& v)
317 if(!v(ref_nested())) return false;
318 { type = 1; return true;}
322 template<typename V> bool encode(V& v) const
324 return v(ref_nested());
328 template<typename V> bool decode(size_t index, V& v)
333 case 1: type = 1; return v(ref_nested());
334 ref_nested().clear();
339 template<typename V> bool encode(size_t index, V& v) const
341 if(index != type) {return false;} return v(ref_nested());
348 struct Extension_t : asn::typefield<true>
350 ~Extension_t() {clear();}
351 size_t get_index() const {return type;}
352 bool is_unknown() const { return type == 1; }
355 type = 0; ref_nested().clear();
357 template<typename V> static inline void enumerate(V& v)
362 template<typename V> bool decode(size_t index, V& v)
367 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
372 template<typename V> bool encode(size_t index, V& v) const
374 if(index != type) return false;
382 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
384 size_t get_index() const {return type;}
385 bool is_unknown() const { return type == 1; }
386 void clear() {type = 0;}
387 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
388 template<typename V> bool decode(V& v)
391 if(!v(ref_nested())) return false;
392 { type = 1; return true;}
396 template<typename V> bool encode(V& v) const
398 return v(ref_nested());
402 template<typename V> bool decode(size_t index, V& v)
407 case 1: type = 1; return v(ref_nested());
408 ref_nested().clear();
413 template<typename V> bool encode(size_t index, V& v) const
415 if(index != type) {return false;} return v(ref_nested());
425 ActivatedNRCellList-Item::= SEQUENCE {
427 iE-Extensions ProtocolExtensionContainer { {ActivatedNRCellList-Item-ExtIEs} } OPTIONAL,
432 struct ActivatedNRCellList_Item : asn::sequence<2, 0, true, 1>
434 static constexpr const char* name() {return "ActivatedNRCellList-Item";}
435 using parent_t = asn::sequence<2, 0, true, 1>;
436 struct nrCellID_t : NRCGI
438 static constexpr const char* name() {return "nrCellID_t";}
439 using parent_t = NRCGI;
442 nrCellID_t& ref_nrCellID() {return nrCellID;}
443 nrCellID_t const& ref_nrCellID() const {return nrCellID;}
444 struct iE_Extensions_t : ProtocolExtensionContainer<ActivatedNRCellList_Item_ExtIEs>
446 static constexpr const char* name() {return "iE_Extensions_t";}
447 using parent_t = ProtocolExtensionContainer<ActivatedNRCellList_Item_ExtIEs>;
448 static constexpr bool optional = true;
451 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
452 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
453 template<typename V> void decode(V& v)
459 template<typename V> void encode(V& v) const
468 iE_Extensions.clear();
473 iE_Extensions_t iE_Extensions;
477 ActivatedNRCellList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ActivatedNRCellList-Item
480 struct ActivatedNRCellList_elm : ActivatedNRCellList_Item
482 static constexpr const char* name() {return "ActivatedNRCellList_elm";}
483 using parent_t = ActivatedNRCellList_Item;
486 struct ActivatedNRCellList : asn::sequenceof<ActivatedNRCellList_elm>
488 static constexpr const char* name() {return "ActivatedNRCellList";}
489 using parent_t = asn::sequenceof<ActivatedNRCellList_elm>;
490 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
494 CellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
495 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory }|
496 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional },
501 struct CellActivationFailure_IEs
503 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
505 size_t get_index() const {return type;}
506 bool is_unknown() const { return type == 3; }
507 void clear() {type = 0;}
508 void select_id_Cause() { set(id_Cause); type=1;}
509 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
510 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
511 template<typename V> bool decode(V& v)
514 if(!v(ref_nested())) return false;
515 if(equal(id_Cause)) { type = 1; return true; }
516 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
517 else { type = 3; return true;}
521 template<typename V> bool encode(V& v) const
523 return v(ref_nested());
527 template<typename V> bool decode(size_t index, V& v)
532 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
533 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
534 case 3: type = 3; return v(ref_nested());
535 ref_nested().clear();
540 template<typename V> bool encode(size_t index, V& v) const
542 if(index != type) {return false;} return v(ref_nested());
549 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
551 size_t get_index() const {return type;}
552 bool is_unknown() const { return type == 3; }
553 void clear() {type = 0;}
554 void select_id_Cause() { set(ignore); type=1;}
555 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
556 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
557 template<typename V> bool decode(V& v)
560 if(!v(ref_nested())) return false;
561 if(equal(ignore)) { type = 1; return true; }
562 else if(equal(ignore)) { type = 2; return true; }
563 else { type = 3; return true;}
567 template<typename V> bool encode(V& v) const
569 return v(ref_nested());
573 template<typename V> bool decode(size_t index, V& v)
578 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
579 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
580 case 3: type = 3; return v(ref_nested());
581 ref_nested().clear();
586 template<typename V> bool encode(size_t index, V& v) const
588 if(index != type) {return false;} return v(ref_nested());
595 struct Value_t : asn::typefield<true>
597 ~Value_t() {clear();}
598 size_t get_index() const {return type;}
599 Cause& select_id_Cause() { return set<Cause>(1); }
600 Cause const* get_id_Cause() const { return get<Cause>(1); }
601 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
602 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
603 bool is_unknown() const { return type == 3; }
608 case 1: var.destroy<Cause>(); break;
609 case 2: var.destroy<CriticalityDiagnostics>(); break;
611 type = 0; ref_nested().clear();
613 template<typename V> static inline void enumerate(V& v)
615 v.template operator()<Cause>(1);
616 v.template operator()<CriticalityDiagnostics>(2);
620 template<typename V> bool decode(size_t index, V& v)
625 case 1: v(select_id_Cause()); return true;
626 case 2: v(select_id_CriticalityDiagnostics()); return true;
627 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
632 template<typename V> bool encode(size_t index, V& v) const
634 if(index != type) return false;
637 case 1: v(var.as<Cause>()); return true;
638 case 2: v(var.as<CriticalityDiagnostics>()); return true;
644 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
645 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
648 char dummy1[sizeof(Cause)];
649 char dummy2[sizeof(CriticalityDiagnostics)];
652 asn::variant<sizeof(union_type)> var;
656 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
658 size_t get_index() const {return type;}
659 bool is_unknown() const { return type == 3; }
660 void clear() {type = 0;}
661 void select_id_Cause() { set(mandatory); type=1;}
662 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
663 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
664 template<typename V> bool decode(V& v)
667 if(!v(ref_nested())) return false;
668 if(equal(mandatory)) { type = 1; return true; }
669 else if(equal(optional)) { type = 2; return true; }
670 else { type = 3; return true;}
674 template<typename V> bool encode(V& v) const
676 return v(ref_nested());
680 template<typename V> bool decode(size_t index, V& v)
685 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
686 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
687 case 3: type = 3; return v(ref_nested());
688 ref_nested().clear();
693 template<typename V> bool encode(size_t index, V& v) const
695 if(index != type) {return false;} return v(ref_nested());
705 CellActivationFailure ::= SEQUENCE {
706 protocolIEs ProtocolIE-Container {{CellActivationFailure-IEs}},
711 struct CellActivationFailure : asn::sequence<1, 0, true, 0>
713 static constexpr const char* name() {return "CellActivationFailure";}
714 using parent_t = asn::sequence<1, 0, true, 0>;
715 struct protocolIEs_t : ProtocolIE_Container<CellActivationFailure_IEs>
717 static constexpr const char* name() {return "protocolIEs_t";}
718 using parent_t = ProtocolIE_Container<CellActivationFailure_IEs>;
721 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
722 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
723 template<typename V> void decode(V& v)
728 template<typename V> void encode(V& v) const
739 protocolIEs_t protocolIEs;
743 ServedCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
748 struct ServedCellsToActivate_Item_ExtIEs
750 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
752 size_t get_index() const {return type;}
753 bool is_unknown() const { return type == 1; }
754 void clear() {type = 0;}
755 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
756 template<typename V> bool decode(V& v)
759 if(!v(ref_nested())) return false;
760 { type = 1; return true;}
764 template<typename V> bool encode(V& v) const
766 return v(ref_nested());
770 template<typename V> bool decode(size_t index, V& v)
775 case 1: type = 1; return v(ref_nested());
776 ref_nested().clear();
781 template<typename V> bool encode(size_t index, V& v) const
783 if(index != type) {return false;} return v(ref_nested());
790 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
792 size_t get_index() const {return type;}
793 bool is_unknown() const { return type == 1; }
794 void clear() {type = 0;}
795 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
796 template<typename V> bool decode(V& v)
799 if(!v(ref_nested())) return false;
800 { type = 1; return true;}
804 template<typename V> bool encode(V& v) const
806 return v(ref_nested());
810 template<typename V> bool decode(size_t index, V& v)
815 case 1: type = 1; return v(ref_nested());
816 ref_nested().clear();
821 template<typename V> bool encode(size_t index, V& v) const
823 if(index != type) {return false;} return v(ref_nested());
830 struct Extension_t : asn::typefield<true>
832 ~Extension_t() {clear();}
833 size_t get_index() const {return type;}
834 bool is_unknown() const { return type == 1; }
837 type = 0; ref_nested().clear();
839 template<typename V> static inline void enumerate(V& v)
844 template<typename V> bool decode(size_t index, V& v)
849 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
854 template<typename V> bool encode(size_t index, V& v) const
856 if(index != type) return false;
864 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
866 size_t get_index() const {return type;}
867 bool is_unknown() const { return type == 1; }
868 void clear() {type = 0;}
869 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
870 template<typename V> bool decode(V& v)
873 if(!v(ref_nested())) return false;
874 { type = 1; return true;}
878 template<typename V> bool encode(V& v) const
880 return v(ref_nested());
884 template<typename V> bool decode(size_t index, V& v)
889 case 1: type = 1; return v(ref_nested());
890 ref_nested().clear();
895 template<typename V> bool encode(size_t index, V& v) const
897 if(index != type) {return false;} return v(ref_nested());
907 ServedCellsToActivate-Item::= SEQUENCE {
909 iE-Extensions ProtocolExtensionContainer { {ServedCellsToActivate-Item-ExtIEs} } OPTIONAL,
914 struct ServedCellsToActivate_Item : asn::sequence<2, 0, true, 1>
916 static constexpr const char* name() {return "ServedCellsToActivate-Item";}
917 using parent_t = asn::sequence<2, 0, true, 1>;
920 static constexpr const char* name() {return "ecgi_t";}
921 using parent_t = ECGI;
924 ecgi_t& ref_ecgi() {return ecgi;}
925 ecgi_t const& ref_ecgi() const {return ecgi;}
926 struct iE_Extensions_t : ProtocolExtensionContainer<ServedCellsToActivate_Item_ExtIEs>
928 static constexpr const char* name() {return "iE_Extensions_t";}
929 using parent_t = ProtocolExtensionContainer<ServedCellsToActivate_Item_ExtIEs>;
930 static constexpr bool optional = true;
933 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
934 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
935 template<typename V> void decode(V& v)
941 template<typename V> void encode(V& v) const
950 iE_Extensions.clear();
955 iE_Extensions_t iE_Extensions;
959 ServedCellsToActivate::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToActivate-Item
962 struct ServedCellsToActivate_elm : ServedCellsToActivate_Item
964 static constexpr const char* name() {return "ServedCellsToActivate_elm";}
965 using parent_t = ServedCellsToActivate_Item;
968 struct ServedCellsToActivate : asn::sequenceof<ServedCellsToActivate_elm>
970 static constexpr const char* name() {return "ServedCellsToActivate";}
971 using parent_t = asn::sequenceof<ServedCellsToActivate_elm>;
972 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
976 CellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
977 { ID id-ServedCellsToActivate CRITICALITY reject TYPE ServedCellsToActivate PRESENCE mandatory},
982 struct CellActivationRequest_IEs
984 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
986 size_t get_index() const {return type;}
987 bool is_unknown() const { return type == 2; }
988 void clear() {type = 0;}
989 void select_id_ServedCellsToActivate() { set(id_ServedCellsToActivate); type=1;}
990 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
991 template<typename V> bool decode(V& v)
994 if(!v(ref_nested())) return false;
995 if(equal(id_ServedCellsToActivate)) { type = 1; return true; }
996 else { type = 2; return true;}
1000 template<typename V> bool encode(V& v) const
1002 return v(ref_nested());
1006 template<typename V> bool decode(size_t index, V& v)
1011 case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedCellsToActivate);} return false;
1012 case 2: type = 2; return v(ref_nested());
1013 ref_nested().clear();
1018 template<typename V> bool encode(size_t index, V& v) const
1020 if(index != type) {return false;} return v(ref_nested());
1027 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
1029 size_t get_index() const {return type;}
1030 bool is_unknown() const { return type == 2; }
1031 void clear() {type = 0;}
1032 void select_id_ServedCellsToActivate() { set(reject); type=1;}
1033 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
1034 template<typename V> bool decode(V& v)
1037 if(!v(ref_nested())) return false;
1038 if(equal(reject)) { type = 1; return true; }
1039 else { type = 2; return true;}
1043 template<typename V> bool encode(V& v) const
1045 return v(ref_nested());
1049 template<typename V> bool decode(size_t index, V& v)
1054 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
1055 case 2: type = 2; return v(ref_nested());
1056 ref_nested().clear();
1061 template<typename V> bool encode(size_t index, V& v) const
1063 if(index != type) {return false;} return v(ref_nested());
1070 struct Value_t : asn::typefield<true>
1072 ~Value_t() {clear();}
1073 size_t get_index() const {return type;}
1074 ServedCellsToActivate& select_id_ServedCellsToActivate() { return set<ServedCellsToActivate>(1); }
1075 ServedCellsToActivate const* get_id_ServedCellsToActivate() const { return get<ServedCellsToActivate>(1); }
1076 bool is_unknown() const { return type == 2; }
1081 case 1: var.destroy<ServedCellsToActivate>(); break;
1083 type = 0; ref_nested().clear();
1085 template<typename V> static inline void enumerate(V& v)
1087 v.template operator()<ServedCellsToActivate>(1);
1091 template<typename V> bool decode(size_t index, V& v)
1096 case 1: v(select_id_ServedCellsToActivate()); return true;
1097 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
1102 template<typename V> bool encode(size_t index, V& v) const
1104 if(index != type) return false;
1107 case 1: v(var.as<ServedCellsToActivate>()); return true;
1113 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1114 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1117 char dummy1[sizeof(ServedCellsToActivate)];
1120 asn::variant<sizeof(union_type)> var;
1124 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
1126 size_t get_index() const {return type;}
1127 bool is_unknown() const { return type == 2; }
1128 void clear() {type = 0;}
1129 void select_id_ServedCellsToActivate() { set(mandatory); type=1;}
1130 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
1131 template<typename V> bool decode(V& v)
1134 if(!v(ref_nested())) return false;
1135 if(equal(mandatory)) { type = 1; return true; }
1136 else { type = 2; return true;}
1140 template<typename V> bool encode(V& v) const
1142 return v(ref_nested());
1146 template<typename V> bool decode(size_t index, V& v)
1151 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
1152 case 2: type = 2; return v(ref_nested());
1153 ref_nested().clear();
1158 template<typename V> bool encode(size_t index, V& v) const
1160 if(index != type) {return false;} return v(ref_nested());
1170 CellActivationRequest ::= SEQUENCE {
1171 protocolIEs ProtocolIE-Container {{CellActivationRequest-IEs}},
1176 struct CellActivationRequest : asn::sequence<1, 0, true, 0>
1178 static constexpr const char* name() {return "CellActivationRequest";}
1179 using parent_t = asn::sequence<1, 0, true, 0>;
1180 struct protocolIEs_t : ProtocolIE_Container<CellActivationRequest_IEs>
1182 static constexpr const char* name() {return "protocolIEs_t";}
1183 using parent_t = ProtocolIE_Container<CellActivationRequest_IEs>;
1186 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
1187 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
1188 template<typename V> void decode(V& v)
1193 template<typename V> void encode(V& v) const
1200 protocolIEs.clear();
1204 protocolIEs_t protocolIEs;
1208 CellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
1209 { ID id-ActivatedCellList CRITICALITY ignore TYPE ActivatedCellList PRESENCE mandatory}|
1210 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
1215 struct CellActivationResponse_IEs
1217 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
1219 size_t get_index() const {return type;}
1220 bool is_unknown() const { return type == 3; }
1221 void clear() {type = 0;}
1222 void select_id_ActivatedCellList() { set(id_ActivatedCellList); type=1;}
1223 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
1224 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
1225 template<typename V> bool decode(V& v)
1228 if(!v(ref_nested())) return false;
1229 if(equal(id_ActivatedCellList)) { type = 1; return true; }
1230 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
1231 else { type = 3; return true;}
1235 template<typename V> bool encode(V& v) const
1237 return v(ref_nested());
1241 template<typename V> bool decode(size_t index, V& v)
1246 case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivatedCellList);} return false;
1247 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
1248 case 3: type = 3; return v(ref_nested());
1249 ref_nested().clear();
1254 template<typename V> bool encode(size_t index, V& v) const
1256 if(index != type) {return false;} return v(ref_nested());
1263 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
1265 size_t get_index() const {return type;}
1266 bool is_unknown() const { return type == 3; }
1267 void clear() {type = 0;}
1268 void select_id_ActivatedCellList() { set(ignore); type=1;}
1269 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
1270 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
1271 template<typename V> bool decode(V& v)
1274 if(!v(ref_nested())) return false;
1275 if(equal(ignore)) { type = 1; return true; }
1276 else if(equal(ignore)) { type = 2; return true; }
1277 else { type = 3; return true;}
1281 template<typename V> bool encode(V& v) const
1283 return v(ref_nested());
1287 template<typename V> bool decode(size_t index, V& v)
1292 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
1293 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
1294 case 3: type = 3; return v(ref_nested());
1295 ref_nested().clear();
1300 template<typename V> bool encode(size_t index, V& v) const
1302 if(index != type) {return false;} return v(ref_nested());
1309 struct Value_t : asn::typefield<true>
1311 ~Value_t() {clear();}
1312 size_t get_index() const {return type;}
1313 ActivatedCellList& select_id_ActivatedCellList() { return set<ActivatedCellList>(1); }
1314 ActivatedCellList const* get_id_ActivatedCellList() const { return get<ActivatedCellList>(1); }
1315 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
1316 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
1317 bool is_unknown() const { return type == 3; }
1322 case 1: var.destroy<ActivatedCellList>(); break;
1323 case 2: var.destroy<CriticalityDiagnostics>(); break;
1325 type = 0; ref_nested().clear();
1327 template<typename V> static inline void enumerate(V& v)
1329 v.template operator()<ActivatedCellList>(1);
1330 v.template operator()<CriticalityDiagnostics>(2);
1334 template<typename V> bool decode(size_t index, V& v)
1339 case 1: v(select_id_ActivatedCellList()); return true;
1340 case 2: v(select_id_CriticalityDiagnostics()); return true;
1341 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
1346 template<typename V> bool encode(size_t index, V& v) const
1348 if(index != type) return false;
1351 case 1: v(var.as<ActivatedCellList>()); return true;
1352 case 2: v(var.as<CriticalityDiagnostics>()); return true;
1358 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1359 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1362 char dummy1[sizeof(ActivatedCellList)];
1363 char dummy2[sizeof(CriticalityDiagnostics)];
1366 asn::variant<sizeof(union_type)> var;
1370 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
1372 size_t get_index() const {return type;}
1373 bool is_unknown() const { return type == 3; }
1374 void clear() {type = 0;}
1375 void select_id_ActivatedCellList() { set(mandatory); type=1;}
1376 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
1377 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
1378 template<typename V> bool decode(V& v)
1381 if(!v(ref_nested())) return false;
1382 if(equal(mandatory)) { type = 1; return true; }
1383 else if(equal(optional)) { type = 2; return true; }
1384 else { type = 3; return true;}
1388 template<typename V> bool encode(V& v) const
1390 return v(ref_nested());
1394 template<typename V> bool decode(size_t index, V& v)
1399 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
1400 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
1401 case 3: type = 3; return v(ref_nested());
1402 ref_nested().clear();
1407 template<typename V> bool encode(size_t index, V& v) const
1409 if(index != type) {return false;} return v(ref_nested());
1419 CellActivationResponse ::= SEQUENCE {
1420 protocolIEs ProtocolIE-Container {{CellActivationResponse-IEs}},
1425 struct CellActivationResponse : asn::sequence<1, 0, true, 0>
1427 static constexpr const char* name() {return "CellActivationResponse";}
1428 using parent_t = asn::sequence<1, 0, true, 0>;
1429 struct protocolIEs_t : ProtocolIE_Container<CellActivationResponse_IEs>
1431 static constexpr const char* name() {return "protocolIEs_t";}
1432 using parent_t = ProtocolIE_Container<CellActivationResponse_IEs>;
1435 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
1436 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
1437 template<typename V> void decode(V& v)
1442 template<typename V> void encode(V& v) const
1449 protocolIEs.clear();
1453 protocolIEs_t protocolIEs;
1457 Limited-list-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1462 struct Limited_list_ExtIEs
1464 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1466 size_t get_index() const {return type;}
1467 bool is_unknown() const { return type == 1; }
1468 void clear() {type = 0;}
1469 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1470 template<typename V> bool decode(V& v)
1473 if(!v(ref_nested())) return false;
1474 { type = 1; return true;}
1478 template<typename V> bool encode(V& v) const
1480 return v(ref_nested());
1484 template<typename V> bool decode(size_t index, V& v)
1489 case 1: type = 1; return v(ref_nested());
1490 ref_nested().clear();
1495 template<typename V> bool encode(size_t index, V& v) const
1497 if(index != type) {return false;} return v(ref_nested());
1504 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1506 size_t get_index() const {return type;}
1507 bool is_unknown() const { return type == 1; }
1508 void clear() {type = 0;}
1509 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1510 template<typename V> bool decode(V& v)
1513 if(!v(ref_nested())) return false;
1514 { type = 1; return true;}
1518 template<typename V> bool encode(V& v) const
1520 return v(ref_nested());
1524 template<typename V> bool decode(size_t index, V& v)
1529 case 1: type = 1; return v(ref_nested());
1530 ref_nested().clear();
1535 template<typename V> bool encode(size_t index, V& v) const
1537 if(index != type) {return false;} return v(ref_nested());
1544 struct Extension_t : asn::typefield<true>
1546 ~Extension_t() {clear();}
1547 size_t get_index() const {return type;}
1548 bool is_unknown() const { return type == 1; }
1551 type = 0; ref_nested().clear();
1553 template<typename V> static inline void enumerate(V& v)
1558 template<typename V> bool decode(size_t index, V& v)
1563 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1568 template<typename V> bool encode(size_t index, V& v) const
1570 if(index != type) return false;
1578 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1580 size_t get_index() const {return type;}
1581 bool is_unknown() const { return type == 1; }
1582 void clear() {type = 0;}
1583 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1584 template<typename V> bool decode(V& v)
1587 if(!v(ref_nested())) return false;
1588 { type = 1; return true;}
1592 template<typename V> bool encode(V& v) const
1594 return v(ref_nested());
1598 template<typename V> bool decode(size_t index, V& v)
1603 case 1: type = 1; return v(ref_nested());
1604 ref_nested().clear();
1609 template<typename V> bool encode(size_t index, V& v) const
1611 if(index != type) {return false;} return v(ref_nested());
1621 Limited-list ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF SEQUENCE {
1623 iE-Extensions ProtocolExtensionContainer { {Limited-list-ExtIEs} } OPTIONAL,
1628 struct Limited_list_elm : asn::sequence<2, 0, true, 1>
1630 static constexpr const char* name() {return "Limited_list_elm";}
1631 using parent_t = asn::sequence<2, 0, true, 1>;
1632 struct nrCellID_t : NRCGI
1634 static constexpr const char* name() {return "nrCellID_t";}
1635 using parent_t = NRCGI;
1638 nrCellID_t& ref_nrCellID() {return nrCellID;}
1639 nrCellID_t const& ref_nrCellID() const {return nrCellID;}
1640 struct iE_Extensions_t : ProtocolExtensionContainer<Limited_list_ExtIEs>
1642 static constexpr const char* name() {return "iE_Extensions_t";}
1643 using parent_t = ProtocolExtensionContainer<Limited_list_ExtIEs>;
1644 static constexpr bool optional = true;
1647 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1648 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1649 template<typename V> void decode(V& v)
1655 template<typename V> void encode(V& v) const
1664 iE_Extensions.clear();
1668 nrCellID_t nrCellID;
1669 iE_Extensions_t iE_Extensions;
1672 struct Limited_list : asn::sequenceof<Limited_list_elm>
1674 static constexpr const char* name() {return "Limited-list";}
1675 using parent_t = asn::sequenceof<Limited_list_elm>;
1676 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
1680 CellAssistanceInformation ::= CHOICE {
1681 limited-list Limited-list,
1682 full-list ENUMERATED {allServedNRcells, ...},
1687 struct CellAssistanceInformation : asn::choice<2, 0, true>
1689 static constexpr const char* name() {return "CellAssistanceInformation";}
1690 using parent_t = asn::choice<2, 0, true>;
1691 index_type get_index() const {return index;}
1692 bool is_unknown() const {return index == 3;}
1693 void set_unknown() { set_index(3); }
1694 ~CellAssistanceInformation() {clear();}
1695 struct limited_list_t : Limited_list
1697 static constexpr const char* name() {return "limited_list_t";}
1698 using parent_t = Limited_list;
1701 struct full_list_t : asn::enumerated<1, 0, true>
1703 static constexpr const char* name() {return "full_list_t";}
1704 using parent_t = asn::enumerated<1, 0, true>;
1715 case 1: var.destroy<limited_list_t>(); break;
1716 case 2: var.destroy<full_list_t>(); break;
1721 template<typename V> bool decode(size_t idx, V& v)
1726 case 1: set_index(1); return v(var.build<limited_list_t>());
1727 case 2: set_index(2); return v(var.build<full_list_t>());
1732 template<typename V> bool encode(V& v) const
1736 case 1: return v(var.as<limited_list_t>());
1737 case 2: return v(var.as<full_list_t>());
1741 template<typename V> static inline void enumerate(V& v)
1743 v.template operator()<limited_list_t>(1);
1744 v.template operator()<full_list_t>(2);
1747 limited_list_t& select_limited_list() { if(get_index() != 1) { clear(); set_index(1); return var.build<limited_list_t>();} return var.as<limited_list_t>();}
1748 limited_list_t const* get_limited_list() const { if(get_index() == 1) { return &var.as<limited_list_t>();} return nullptr; }
1749 full_list_t& select_full_list() { if(get_index() != 2) { clear(); set_index(2); return var.build<full_list_t>();} return var.as<full_list_t>();}
1750 full_list_t const* get_full_list() const { if(get_index() == 2) { return &var.as<full_list_t>();} return nullptr; }
1752 void set_index(index_type i) {index = i; base::set();}
1755 char dummy1[sizeof(limited_list_t)];
1756 char dummy2[sizeof(full_list_t)];
1759 asn::variant<sizeof(union_type)> var;
1760 index_type index {0};
1763 CellInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1764 { ID id-ABSInformation CRITICALITY ignore EXTENSION ABSInformation PRESENCE optional }|
1765 { ID id-InvokeIndication CRITICALITY ignore EXTENSION InvokeIndication PRESENCE optional }|
1766 { ID id-IntendedULDLConfiguration CRITICALITY ignore EXTENSION SubframeAssignment PRESENCE optional }|
1767 { ID id-ExtendedULInterferenceOverloadInfo CRITICALITY ignore EXTENSION ExtendedULInterferenceOverloadInfo PRESENCE optional }|
1768 { ID id-CoMPInformation CRITICALITY ignore EXTENSION CoMPInformation PRESENCE optional }|
1769 { ID id-DynamicDLTransmissionInformation CRITICALITY ignore EXTENSION DynamicDLTransmissionInformation PRESENCE optional },
1774 struct CellInformation_Item_ExtIEs
1776 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1778 size_t get_index() const {return type;}
1779 bool is_unknown() const { return type == 7; }
1780 void clear() {type = 0;}
1781 void select_id_ABSInformation() { set(id_ABSInformation); type=1;}
1782 void select_id_InvokeIndication() { set(id_InvokeIndication); type=2;}
1783 void select_id_IntendedULDLConfiguration() { set(id_IntendedULDLConfiguration); type=3;}
1784 void select_id_ExtendedULInterferenceOverloadInfo() { set(id_ExtendedULInterferenceOverloadInfo); type=4;}
1785 void select_id_CoMPInformation() { set(id_CoMPInformation); type=5;}
1786 void select_id_DynamicDLTransmissionInformation() { set(id_DynamicDLTransmissionInformation); type=6;}
1787 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1788 template<typename V> bool decode(V& v)
1791 if(!v(ref_nested())) return false;
1792 if(equal(id_ABSInformation)) { type = 1; return true; }
1793 else if(equal(id_InvokeIndication)) { type = 2; return true; }
1794 else if(equal(id_IntendedULDLConfiguration)) { type = 3; return true; }
1795 else if(equal(id_ExtendedULInterferenceOverloadInfo)) { type = 4; return true; }
1796 else if(equal(id_CoMPInformation)) { type = 5; return true; }
1797 else if(equal(id_DynamicDLTransmissionInformation)) { type = 6; return true; }
1798 else { type = 7; return true;}
1802 template<typename V> bool encode(V& v) const
1804 return v(ref_nested());
1808 template<typename V> bool decode(size_t index, V& v)
1813 case 1: type = 1; if(v(ref_nested())) { return equal(id_ABSInformation);} return false;
1814 case 2: type = 2; if(v(ref_nested())) { return equal(id_InvokeIndication);} return false;
1815 case 3: type = 3; if(v(ref_nested())) { return equal(id_IntendedULDLConfiguration);} return false;
1816 case 4: type = 4; if(v(ref_nested())) { return equal(id_ExtendedULInterferenceOverloadInfo);} return false;
1817 case 5: type = 5; if(v(ref_nested())) { return equal(id_CoMPInformation);} return false;
1818 case 6: type = 6; if(v(ref_nested())) { return equal(id_DynamicDLTransmissionInformation);} return false;
1819 case 7: type = 7; return v(ref_nested());
1820 ref_nested().clear();
1825 template<typename V> bool encode(size_t index, V& v) const
1827 if(index != type) {return false;} return v(ref_nested());
1834 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1836 size_t get_index() const {return type;}
1837 bool is_unknown() const { return type == 7; }
1838 void clear() {type = 0;}
1839 void select_id_ABSInformation() { set(ignore); type=1;}
1840 void select_id_InvokeIndication() { set(ignore); type=2;}
1841 void select_id_IntendedULDLConfiguration() { set(ignore); type=3;}
1842 void select_id_ExtendedULInterferenceOverloadInfo() { set(ignore); type=4;}
1843 void select_id_CoMPInformation() { set(ignore); type=5;}
1844 void select_id_DynamicDLTransmissionInformation() { set(ignore); type=6;}
1845 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1846 template<typename V> bool decode(V& v)
1849 if(!v(ref_nested())) return false;
1850 if(equal(ignore)) { type = 1; return true; }
1851 else if(equal(ignore)) { type = 2; return true; }
1852 else if(equal(ignore)) { type = 3; return true; }
1853 else if(equal(ignore)) { type = 4; return true; }
1854 else if(equal(ignore)) { type = 5; return true; }
1855 else if(equal(ignore)) { type = 6; return true; }
1856 else { type = 7; return true;}
1860 template<typename V> bool encode(V& v) const
1862 return v(ref_nested());
1866 template<typename V> bool decode(size_t index, V& v)
1871 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
1872 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
1873 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
1874 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
1875 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
1876 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
1877 case 7: type = 7; return v(ref_nested());
1878 ref_nested().clear();
1883 template<typename V> bool encode(size_t index, V& v) const
1885 if(index != type) {return false;} return v(ref_nested());
1892 struct Extension_t : asn::typefield<true>
1894 ~Extension_t() {clear();}
1895 size_t get_index() const {return type;}
1896 ABSInformation& select_id_ABSInformation() { return set<ABSInformation>(1); }
1897 ABSInformation const* get_id_ABSInformation() const { return get<ABSInformation>(1); }
1898 InvokeIndication& select_id_InvokeIndication() { return set<InvokeIndication>(2); }
1899 InvokeIndication const* get_id_InvokeIndication() const { return get<InvokeIndication>(2); }
1900 SubframeAssignment& select_id_IntendedULDLConfiguration() { return set<SubframeAssignment>(3); }
1901 SubframeAssignment const* get_id_IntendedULDLConfiguration() const { return get<SubframeAssignment>(3); }
1902 ExtendedULInterferenceOverloadInfo& select_id_ExtendedULInterferenceOverloadInfo() { return set<ExtendedULInterferenceOverloadInfo>(4); }
1903 ExtendedULInterferenceOverloadInfo const* get_id_ExtendedULInterferenceOverloadInfo() const { return get<ExtendedULInterferenceOverloadInfo>(4); }
1904 CoMPInformation& select_id_CoMPInformation() { return set<CoMPInformation>(5); }
1905 CoMPInformation const* get_id_CoMPInformation() const { return get<CoMPInformation>(5); }
1906 DynamicDLTransmissionInformation& select_id_DynamicDLTransmissionInformation() { return set<DynamicDLTransmissionInformation>(6); }
1907 DynamicDLTransmissionInformation const* get_id_DynamicDLTransmissionInformation() const { return get<DynamicDLTransmissionInformation>(6); }
1908 bool is_unknown() const { return type == 7; }
1913 case 1: var.destroy<ABSInformation>(); break;
1914 case 2: var.destroy<InvokeIndication>(); break;
1915 case 3: var.destroy<SubframeAssignment>(); break;
1916 case 4: var.destroy<ExtendedULInterferenceOverloadInfo>(); break;
1917 case 5: var.destroy<CoMPInformation>(); break;
1918 case 6: var.destroy<DynamicDLTransmissionInformation>(); break;
1920 type = 0; ref_nested().clear();
1922 template<typename V> static inline void enumerate(V& v)
1924 v.template operator()<ABSInformation>(1);
1925 v.template operator()<InvokeIndication>(2);
1926 v.template operator()<SubframeAssignment>(3);
1927 v.template operator()<ExtendedULInterferenceOverloadInfo>(4);
1928 v.template operator()<CoMPInformation>(5);
1929 v.template operator()<DynamicDLTransmissionInformation>(6);
1933 template<typename V> bool decode(size_t index, V& v)
1938 case 1: v(select_id_ABSInformation()); return true;
1939 case 2: v(select_id_InvokeIndication()); return true;
1940 case 3: v(select_id_IntendedULDLConfiguration()); return true;
1941 case 4: v(select_id_ExtendedULInterferenceOverloadInfo()); return true;
1942 case 5: v(select_id_CoMPInformation()); return true;
1943 case 6: v(select_id_DynamicDLTransmissionInformation()); return true;
1944 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
1949 template<typename V> bool encode(size_t index, V& v) const
1951 if(index != type) return false;
1954 case 1: v(var.as<ABSInformation>()); return true;
1955 case 2: v(var.as<InvokeIndication>()); return true;
1956 case 3: v(var.as<SubframeAssignment>()); return true;
1957 case 4: v(var.as<ExtendedULInterferenceOverloadInfo>()); return true;
1958 case 5: v(var.as<CoMPInformation>()); return true;
1959 case 6: v(var.as<DynamicDLTransmissionInformation>()); return true;
1965 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1966 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1969 char dummy1[sizeof(ABSInformation)];
1970 char dummy2[sizeof(CoMPInformation)];
1971 char dummy3[sizeof(DynamicDLTransmissionInformation)];
1972 char dummy4[sizeof(ExtendedULInterferenceOverloadInfo)];
1973 char dummy5[sizeof(InvokeIndication)];
1974 char dummy6[sizeof(SubframeAssignment)];
1977 asn::variant<sizeof(union_type)> var;
1981 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1983 size_t get_index() const {return type;}
1984 bool is_unknown() const { return type == 7; }
1985 void clear() {type = 0;}
1986 void select_id_ABSInformation() { set(optional); type=1;}
1987 void select_id_InvokeIndication() { set(optional); type=2;}
1988 void select_id_IntendedULDLConfiguration() { set(optional); type=3;}
1989 void select_id_ExtendedULInterferenceOverloadInfo() { set(optional); type=4;}
1990 void select_id_CoMPInformation() { set(optional); type=5;}
1991 void select_id_DynamicDLTransmissionInformation() { set(optional); type=6;}
1992 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1993 template<typename V> bool decode(V& v)
1996 if(!v(ref_nested())) return false;
1997 if(equal(optional)) { type = 1; return true; }
1998 else if(equal(optional)) { type = 2; return true; }
1999 else if(equal(optional)) { type = 3; return true; }
2000 else if(equal(optional)) { type = 4; return true; }
2001 else if(equal(optional)) { type = 5; return true; }
2002 else if(equal(optional)) { type = 6; return true; }
2003 else { type = 7; return true;}
2007 template<typename V> bool encode(V& v) const
2009 return v(ref_nested());
2013 template<typename V> bool decode(size_t index, V& v)
2018 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
2019 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
2020 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
2021 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
2022 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
2023 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
2024 case 7: type = 7; return v(ref_nested());
2025 ref_nested().clear();
2030 template<typename V> bool encode(size_t index, V& v) const
2032 if(index != type) {return false;} return v(ref_nested());
2042 CellInformation-Item ::= SEQUENCE {
2044 ul-InterferenceOverloadIndication UL-InterferenceOverloadIndication OPTIONAL,
2045 ul-HighInterferenceIndicationInfo UL-HighInterferenceIndicationInfo OPTIONAL,
2046 relativeNarrowbandTxPower RelativeNarrowbandTxPower OPTIONAL,
2047 iE-Extensions ProtocolExtensionContainer { {CellInformation-Item-ExtIEs} } OPTIONAL,
2052 struct CellInformation_Item : asn::sequence<5, 0, true, 4>
2054 static constexpr const char* name() {return "CellInformation-Item";}
2055 using parent_t = asn::sequence<5, 0, true, 4>;
2056 struct cell_ID_t : ECGI
2058 static constexpr const char* name() {return "cell_ID_t";}
2059 using parent_t = ECGI;
2062 cell_ID_t& ref_cell_ID() {return cell_ID;}
2063 cell_ID_t const& ref_cell_ID() const {return cell_ID;}
2064 struct ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
2066 static constexpr const char* name() {return "ul_InterferenceOverloadIndication_t";}
2067 using parent_t = UL_InterferenceOverloadIndication;
2068 static constexpr bool optional = true;
2071 ul_InterferenceOverloadIndication_t& set_ul_InterferenceOverloadIndication() { ul_InterferenceOverloadIndication.setpresent(true); return ul_InterferenceOverloadIndication;}
2072 ul_InterferenceOverloadIndication_t const* get_ul_InterferenceOverloadIndication() const {return ul_InterferenceOverloadIndication.is_valid() ? &ul_InterferenceOverloadIndication : nullptr;}
2073 struct ul_HighInterferenceIndicationInfo_t : UL_HighInterferenceIndicationInfo
2075 static constexpr const char* name() {return "ul_HighInterferenceIndicationInfo_t";}
2076 using parent_t = UL_HighInterferenceIndicationInfo;
2077 static constexpr bool optional = true;
2080 ul_HighInterferenceIndicationInfo_t& set_ul_HighInterferenceIndicationInfo() { ul_HighInterferenceIndicationInfo.setpresent(true); return ul_HighInterferenceIndicationInfo;}
2081 ul_HighInterferenceIndicationInfo_t const* get_ul_HighInterferenceIndicationInfo() const {return ul_HighInterferenceIndicationInfo.is_valid() ? &ul_HighInterferenceIndicationInfo : nullptr;}
2082 struct relativeNarrowbandTxPower_t : RelativeNarrowbandTxPower
2084 static constexpr const char* name() {return "relativeNarrowbandTxPower_t";}
2085 using parent_t = RelativeNarrowbandTxPower;
2086 static constexpr bool optional = true;
2089 relativeNarrowbandTxPower_t& set_relativeNarrowbandTxPower() { relativeNarrowbandTxPower.setpresent(true); return relativeNarrowbandTxPower;}
2090 relativeNarrowbandTxPower_t const* get_relativeNarrowbandTxPower() const {return relativeNarrowbandTxPower.is_valid() ? &relativeNarrowbandTxPower : nullptr;}
2091 struct iE_Extensions_t : ProtocolExtensionContainer<CellInformation_Item_ExtIEs>
2093 static constexpr const char* name() {return "iE_Extensions_t";}
2094 using parent_t = ProtocolExtensionContainer<CellInformation_Item_ExtIEs>;
2095 static constexpr bool optional = true;
2098 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2099 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2100 template<typename V> void decode(V& v)
2103 v(ul_InterferenceOverloadIndication);
2104 v(ul_HighInterferenceIndicationInfo);
2105 v(relativeNarrowbandTxPower);
2109 template<typename V> void encode(V& v) const
2112 v(ul_InterferenceOverloadIndication);
2113 v(ul_HighInterferenceIndicationInfo);
2114 v(relativeNarrowbandTxPower);
2121 ul_InterferenceOverloadIndication.clear();
2122 ul_HighInterferenceIndicationInfo.clear();
2123 relativeNarrowbandTxPower.clear();
2124 iE_Extensions.clear();
2129 ul_InterferenceOverloadIndication_t ul_InterferenceOverloadIndication;
2130 ul_HighInterferenceIndicationInfo_t ul_HighInterferenceIndicationInfo;
2131 relativeNarrowbandTxPower_t relativeNarrowbandTxPower;
2132 iE_Extensions_t iE_Extensions;
2136 CellInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
2137 { ID id-CellInformation-Item CRITICALITY ignore TYPE CellInformation-Item PRESENCE mandatory }
2141 struct CellInformation_ItemIEs
2143 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
2145 size_t get_index() const {return type;}
2146 void clear() {type = 0;}
2147 void select_id_CellInformation_Item() { set(id_CellInformation_Item); type=1;}
2148 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
2149 template<typename V> bool decode(V& v)
2152 if(!v(ref_nested())) return false;
2153 if(equal(id_CellInformation_Item)) { type = 1; return true; }
2157 template<typename V> bool encode(V& v) const
2159 return v(ref_nested());
2163 template<typename V> bool decode(size_t index, V& v)
2168 case 1: type = 1; if(v(ref_nested())) { return equal(id_CellInformation_Item);} return false;
2169 ref_nested().clear();
2174 template<typename V> bool encode(size_t index, V& v) const
2176 if(index != type) {return false;} return v(ref_nested());
2183 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
2185 size_t get_index() const {return type;}
2186 void clear() {type = 0;}
2187 void select_id_CellInformation_Item() { set(ignore); type=1;}
2188 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
2189 template<typename V> bool decode(V& v)
2192 if(!v(ref_nested())) return false;
2193 if(equal(ignore)) { type = 1; return true; }
2197 template<typename V> bool encode(V& v) const
2199 return v(ref_nested());
2203 template<typename V> bool decode(size_t index, V& v)
2208 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2209 ref_nested().clear();
2214 template<typename V> bool encode(size_t index, V& v) const
2216 if(index != type) {return false;} return v(ref_nested());
2223 struct Value_t : asn::typefield<false>
2225 ~Value_t() {clear();}
2226 size_t get_index() const {return type;}
2227 CellInformation_Item& select_id_CellInformation_Item() { return set<CellInformation_Item>(1); }
2228 CellInformation_Item const* get_id_CellInformation_Item() const { return get<CellInformation_Item>(1); }
2233 case 1: var.destroy<CellInformation_Item>(); break;
2235 type = 0; ref_nested().clear();
2237 template<typename V> static inline void enumerate(V& v)
2239 v.template operator()<CellInformation_Item>(1);
2243 template<typename V> bool decode(size_t index, V& v)
2248 case 1: v(select_id_CellInformation_Item()); return true;
2253 template<typename V> bool encode(size_t index, V& v) const
2255 if(index != type) return false;
2258 case 1: v(var.as<CellInformation_Item>()); return true;
2264 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2265 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2268 char dummy1[sizeof(CellInformation_Item)];
2271 asn::variant<sizeof(union_type)> var;
2275 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
2277 size_t get_index() const {return type;}
2278 void clear() {type = 0;}
2279 void select_id_CellInformation_Item() { set(mandatory); type=1;}
2280 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
2281 template<typename V> bool decode(V& v)
2284 if(!v(ref_nested())) return false;
2285 if(equal(mandatory)) { type = 1; return true; }
2289 template<typename V> bool encode(V& v) const
2291 return v(ref_nested());
2295 template<typename V> bool decode(size_t index, V& v)
2300 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
2301 ref_nested().clear();
2306 template<typename V> bool encode(size_t index, V& v) const
2308 if(index != type) {return false;} return v(ref_nested());
2318 CellInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellInformation-ItemIEs} }
2321 struct CellInformation_List_elm : ProtocolIE_Single_Container<CellInformation_ItemIEs>
2323 static constexpr const char* name() {return "CellInformation_List_elm";}
2324 using parent_t = ProtocolIE_Single_Container<CellInformation_ItemIEs>;
2327 struct CellInformation_List : asn::sequenceof<CellInformation_List_elm>
2329 static constexpr const char* name() {return "CellInformation-List";}
2330 using parent_t = asn::sequenceof<CellInformation_List_elm>;
2331 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
2335 CellMeasurementResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2336 { ID id-CompositeAvailableCapacityGroup CRITICALITY ignore EXTENSION CompositeAvailableCapacityGroup PRESENCE optional}|
2337 { ID id-ABS-Status CRITICALITY ignore EXTENSION ABS-Status PRESENCE optional}|
2338 { ID id-RSRPMRList CRITICALITY ignore EXTENSION RSRPMRList PRESENCE optional}|
2339 { ID id-CSIReportList CRITICALITY ignore EXTENSION CSIReportList PRESENCE optional}|
2340 { ID id-CellReportingIndicator CRITICALITY ignore EXTENSION CellReportingIndicator PRESENCE optional},
2345 struct CellMeasurementResult_Item_ExtIEs
2347 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2349 size_t get_index() const {return type;}
2350 bool is_unknown() const { return type == 6; }
2351 void clear() {type = 0;}
2352 void select_id_CompositeAvailableCapacityGroup() { set(id_CompositeAvailableCapacityGroup); type=1;}
2353 void select_id_ABS_Status() { set(id_ABS_Status); type=2;}
2354 void select_id_RSRPMRList() { set(id_RSRPMRList); type=3;}
2355 void select_id_CSIReportList() { set(id_CSIReportList); type=4;}
2356 void select_id_CellReportingIndicator() { set(id_CellReportingIndicator); type=5;}
2357 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2358 template<typename V> bool decode(V& v)
2361 if(!v(ref_nested())) return false;
2362 if(equal(id_CompositeAvailableCapacityGroup)) { type = 1; return true; }
2363 else if(equal(id_ABS_Status)) { type = 2; return true; }
2364 else if(equal(id_RSRPMRList)) { type = 3; return true; }
2365 else if(equal(id_CSIReportList)) { type = 4; return true; }
2366 else if(equal(id_CellReportingIndicator)) { type = 5; return true; }
2367 else { type = 6; return true;}
2371 template<typename V> bool encode(V& v) const
2373 return v(ref_nested());
2377 template<typename V> bool decode(size_t index, V& v)
2382 case 1: type = 1; if(v(ref_nested())) { return equal(id_CompositeAvailableCapacityGroup);} return false;
2383 case 2: type = 2; if(v(ref_nested())) { return equal(id_ABS_Status);} return false;
2384 case 3: type = 3; if(v(ref_nested())) { return equal(id_RSRPMRList);} return false;
2385 case 4: type = 4; if(v(ref_nested())) { return equal(id_CSIReportList);} return false;
2386 case 5: type = 5; if(v(ref_nested())) { return equal(id_CellReportingIndicator);} return false;
2387 case 6: type = 6; return v(ref_nested());
2388 ref_nested().clear();
2393 template<typename V> bool encode(size_t index, V& v) const
2395 if(index != type) {return false;} return v(ref_nested());
2402 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2404 size_t get_index() const {return type;}
2405 bool is_unknown() const { return type == 6; }
2406 void clear() {type = 0;}
2407 void select_id_CompositeAvailableCapacityGroup() { set(ignore); type=1;}
2408 void select_id_ABS_Status() { set(ignore); type=2;}
2409 void select_id_RSRPMRList() { set(ignore); type=3;}
2410 void select_id_CSIReportList() { set(ignore); type=4;}
2411 void select_id_CellReportingIndicator() { set(ignore); type=5;}
2412 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2413 template<typename V> bool decode(V& v)
2416 if(!v(ref_nested())) return false;
2417 if(equal(ignore)) { type = 1; return true; }
2418 else if(equal(ignore)) { type = 2; return true; }
2419 else if(equal(ignore)) { type = 3; return true; }
2420 else if(equal(ignore)) { type = 4; return true; }
2421 else if(equal(ignore)) { type = 5; return true; }
2422 else { type = 6; return true;}
2426 template<typename V> bool encode(V& v) const
2428 return v(ref_nested());
2432 template<typename V> bool decode(size_t index, V& v)
2437 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2438 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
2439 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
2440 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
2441 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
2442 case 6: type = 6; return v(ref_nested());
2443 ref_nested().clear();
2448 template<typename V> bool encode(size_t index, V& v) const
2450 if(index != type) {return false;} return v(ref_nested());
2457 struct Extension_t : asn::typefield<true>
2459 ~Extension_t() {clear();}
2460 size_t get_index() const {return type;}
2461 CompositeAvailableCapacityGroup& select_id_CompositeAvailableCapacityGroup() { return set<CompositeAvailableCapacityGroup>(1); }
2462 CompositeAvailableCapacityGroup const* get_id_CompositeAvailableCapacityGroup() const { return get<CompositeAvailableCapacityGroup>(1); }
2463 ABS_Status& select_id_ABS_Status() { return set<ABS_Status>(2); }
2464 ABS_Status const* get_id_ABS_Status() const { return get<ABS_Status>(2); }
2465 RSRPMRList& select_id_RSRPMRList() { return set<RSRPMRList>(3); }
2466 RSRPMRList const* get_id_RSRPMRList() const { return get<RSRPMRList>(3); }
2467 CSIReportList& select_id_CSIReportList() { return set<CSIReportList>(4); }
2468 CSIReportList const* get_id_CSIReportList() const { return get<CSIReportList>(4); }
2469 CellReportingIndicator& select_id_CellReportingIndicator() { return set<CellReportingIndicator>(5); }
2470 CellReportingIndicator const* get_id_CellReportingIndicator() const { return get<CellReportingIndicator>(5); }
2471 bool is_unknown() const { return type == 6; }
2476 case 1: var.destroy<CompositeAvailableCapacityGroup>(); break;
2477 case 2: var.destroy<ABS_Status>(); break;
2478 case 3: var.destroy<RSRPMRList>(); break;
2479 case 4: var.destroy<CSIReportList>(); break;
2480 case 5: var.destroy<CellReportingIndicator>(); break;
2482 type = 0; ref_nested().clear();
2484 template<typename V> static inline void enumerate(V& v)
2486 v.template operator()<CompositeAvailableCapacityGroup>(1);
2487 v.template operator()<ABS_Status>(2);
2488 v.template operator()<RSRPMRList>(3);
2489 v.template operator()<CSIReportList>(4);
2490 v.template operator()<CellReportingIndicator>(5);
2494 template<typename V> bool decode(size_t index, V& v)
2499 case 1: v(select_id_CompositeAvailableCapacityGroup()); return true;
2500 case 2: v(select_id_ABS_Status()); return true;
2501 case 3: v(select_id_RSRPMRList()); return true;
2502 case 4: v(select_id_CSIReportList()); return true;
2503 case 5: v(select_id_CellReportingIndicator()); return true;
2504 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
2509 template<typename V> bool encode(size_t index, V& v) const
2511 if(index != type) return false;
2514 case 1: v(var.as<CompositeAvailableCapacityGroup>()); return true;
2515 case 2: v(var.as<ABS_Status>()); return true;
2516 case 3: v(var.as<RSRPMRList>()); return true;
2517 case 4: v(var.as<CSIReportList>()); return true;
2518 case 5: v(var.as<CellReportingIndicator>()); return true;
2524 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2525 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2528 char dummy1[sizeof(ABS_Status)];
2529 char dummy2[sizeof(CSIReportList)];
2530 char dummy3[sizeof(CellReportingIndicator)];
2531 char dummy4[sizeof(CompositeAvailableCapacityGroup)];
2532 char dummy5[sizeof(RSRPMRList)];
2535 asn::variant<sizeof(union_type)> var;
2539 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2541 size_t get_index() const {return type;}
2542 bool is_unknown() const { return type == 6; }
2543 void clear() {type = 0;}
2544 void select_id_CompositeAvailableCapacityGroup() { set(optional); type=1;}
2545 void select_id_ABS_Status() { set(optional); type=2;}
2546 void select_id_RSRPMRList() { set(optional); type=3;}
2547 void select_id_CSIReportList() { set(optional); type=4;}
2548 void select_id_CellReportingIndicator() { set(optional); type=5;}
2549 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2550 template<typename V> bool decode(V& v)
2553 if(!v(ref_nested())) return false;
2554 if(equal(optional)) { type = 1; return true; }
2555 else if(equal(optional)) { type = 2; return true; }
2556 else if(equal(optional)) { type = 3; return true; }
2557 else if(equal(optional)) { type = 4; return true; }
2558 else if(equal(optional)) { type = 5; return true; }
2559 else { type = 6; return true;}
2563 template<typename V> bool encode(V& v) const
2565 return v(ref_nested());
2569 template<typename V> bool decode(size_t index, V& v)
2574 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
2575 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
2576 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
2577 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
2578 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
2579 case 6: type = 6; return v(ref_nested());
2580 ref_nested().clear();
2585 template<typename V> bool encode(size_t index, V& v) const
2587 if(index != type) {return false;} return v(ref_nested());
2597 CellMeasurementResult-Item ::= SEQUENCE {
2599 hWLoadIndicator HWLoadIndicator OPTIONAL,
2600 s1TNLLoadIndicator S1TNLLoadIndicator OPTIONAL,
2601 radioResourceStatus RadioResourceStatus OPTIONAL,
2602 iE-Extensions ProtocolExtensionContainer { {CellMeasurementResult-Item-ExtIEs} } OPTIONAL,
2607 struct CellMeasurementResult_Item : asn::sequence<5, 0, true, 4>
2609 static constexpr const char* name() {return "CellMeasurementResult-Item";}
2610 using parent_t = asn::sequence<5, 0, true, 4>;
2611 struct cell_ID_t : ECGI
2613 static constexpr const char* name() {return "cell_ID_t";}
2614 using parent_t = ECGI;
2617 cell_ID_t& ref_cell_ID() {return cell_ID;}
2618 cell_ID_t const& ref_cell_ID() const {return cell_ID;}
2619 struct hWLoadIndicator_t : HWLoadIndicator
2621 static constexpr const char* name() {return "hWLoadIndicator_t";}
2622 using parent_t = HWLoadIndicator;
2623 static constexpr bool optional = true;
2626 hWLoadIndicator_t& set_hWLoadIndicator() { hWLoadIndicator.setpresent(true); return hWLoadIndicator;}
2627 hWLoadIndicator_t const* get_hWLoadIndicator() const {return hWLoadIndicator.is_valid() ? &hWLoadIndicator : nullptr;}
2628 struct s1TNLLoadIndicator_t : S1TNLLoadIndicator
2630 static constexpr const char* name() {return "s1TNLLoadIndicator_t";}
2631 using parent_t = S1TNLLoadIndicator;
2632 static constexpr bool optional = true;
2635 s1TNLLoadIndicator_t& set_s1TNLLoadIndicator() { s1TNLLoadIndicator.setpresent(true); return s1TNLLoadIndicator;}
2636 s1TNLLoadIndicator_t const* get_s1TNLLoadIndicator() const {return s1TNLLoadIndicator.is_valid() ? &s1TNLLoadIndicator : nullptr;}
2637 struct radioResourceStatus_t : RadioResourceStatus
2639 static constexpr const char* name() {return "radioResourceStatus_t";}
2640 using parent_t = RadioResourceStatus;
2641 static constexpr bool optional = true;
2644 radioResourceStatus_t& set_radioResourceStatus() { radioResourceStatus.setpresent(true); return radioResourceStatus;}
2645 radioResourceStatus_t const* get_radioResourceStatus() const {return radioResourceStatus.is_valid() ? &radioResourceStatus : nullptr;}
2646 struct iE_Extensions_t : ProtocolExtensionContainer<CellMeasurementResult_Item_ExtIEs>
2648 static constexpr const char* name() {return "iE_Extensions_t";}
2649 using parent_t = ProtocolExtensionContainer<CellMeasurementResult_Item_ExtIEs>;
2650 static constexpr bool optional = true;
2653 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2654 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2655 template<typename V> void decode(V& v)
2659 v(s1TNLLoadIndicator);
2660 v(radioResourceStatus);
2664 template<typename V> void encode(V& v) const
2668 v(s1TNLLoadIndicator);
2669 v(radioResourceStatus);
2676 hWLoadIndicator.clear();
2677 s1TNLLoadIndicator.clear();
2678 radioResourceStatus.clear();
2679 iE_Extensions.clear();
2684 hWLoadIndicator_t hWLoadIndicator;
2685 s1TNLLoadIndicator_t s1TNLLoadIndicator;
2686 radioResourceStatus_t radioResourceStatus;
2687 iE_Extensions_t iE_Extensions;
2691 CellMeasurementResult-ItemIEs X2AP-PROTOCOL-IES ::= {
2692 { ID id-CellMeasurementResult-Item CRITICALITY ignore TYPE CellMeasurementResult-Item PRESENCE mandatory}
2696 struct CellMeasurementResult_ItemIEs
2698 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
2700 size_t get_index() const {return type;}
2701 void clear() {type = 0;}
2702 void select_id_CellMeasurementResult_Item() { set(id_CellMeasurementResult_Item); type=1;}
2703 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
2704 template<typename V> bool decode(V& v)
2707 if(!v(ref_nested())) return false;
2708 if(equal(id_CellMeasurementResult_Item)) { type = 1; return true; }
2712 template<typename V> bool encode(V& v) const
2714 return v(ref_nested());
2718 template<typename V> bool decode(size_t index, V& v)
2723 case 1: type = 1; if(v(ref_nested())) { return equal(id_CellMeasurementResult_Item);} return false;
2724 ref_nested().clear();
2729 template<typename V> bool encode(size_t index, V& v) const
2731 if(index != type) {return false;} return v(ref_nested());
2738 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
2740 size_t get_index() const {return type;}
2741 void clear() {type = 0;}
2742 void select_id_CellMeasurementResult_Item() { set(ignore); type=1;}
2743 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
2744 template<typename V> bool decode(V& v)
2747 if(!v(ref_nested())) return false;
2748 if(equal(ignore)) { type = 1; return true; }
2752 template<typename V> bool encode(V& v) const
2754 return v(ref_nested());
2758 template<typename V> bool decode(size_t index, V& v)
2763 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2764 ref_nested().clear();
2769 template<typename V> bool encode(size_t index, V& v) const
2771 if(index != type) {return false;} return v(ref_nested());
2778 struct Value_t : asn::typefield<false>
2780 ~Value_t() {clear();}
2781 size_t get_index() const {return type;}
2782 CellMeasurementResult_Item& select_id_CellMeasurementResult_Item() { return set<CellMeasurementResult_Item>(1); }
2783 CellMeasurementResult_Item const* get_id_CellMeasurementResult_Item() const { return get<CellMeasurementResult_Item>(1); }
2788 case 1: var.destroy<CellMeasurementResult_Item>(); break;
2790 type = 0; ref_nested().clear();
2792 template<typename V> static inline void enumerate(V& v)
2794 v.template operator()<CellMeasurementResult_Item>(1);
2798 template<typename V> bool decode(size_t index, V& v)
2803 case 1: v(select_id_CellMeasurementResult_Item()); return true;
2808 template<typename V> bool encode(size_t index, V& v) const
2810 if(index != type) return false;
2813 case 1: v(var.as<CellMeasurementResult_Item>()); return true;
2819 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2820 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2823 char dummy1[sizeof(CellMeasurementResult_Item)];
2826 asn::variant<sizeof(union_type)> var;
2830 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
2832 size_t get_index() const {return type;}
2833 void clear() {type = 0;}
2834 void select_id_CellMeasurementResult_Item() { set(mandatory); type=1;}
2835 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
2836 template<typename V> bool decode(V& v)
2839 if(!v(ref_nested())) return false;
2840 if(equal(mandatory)) { type = 1; return true; }
2844 template<typename V> bool encode(V& v) const
2846 return v(ref_nested());
2850 template<typename V> bool decode(size_t index, V& v)
2855 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
2856 ref_nested().clear();
2861 template<typename V> bool encode(size_t index, V& v) const
2863 if(index != type) {return false;} return v(ref_nested());
2873 CellMeasurementResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellMeasurementResult-ItemIEs} }
2876 struct CellMeasurementResult_List_elm : ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>
2878 static constexpr const char* name() {return "CellMeasurementResult_List_elm";}
2879 using parent_t = ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>;
2882 struct CellMeasurementResult_List : asn::sequenceof<CellMeasurementResult_List_elm>
2884 static constexpr const char* name() {return "CellMeasurementResult-List";}
2885 using parent_t = asn::sequenceof<CellMeasurementResult_List_elm>;
2886 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
2890 CellToReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2895 struct CellToReport_Item_ExtIEs
2897 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2899 size_t get_index() const {return type;}
2900 bool is_unknown() const { return type == 1; }
2901 void clear() {type = 0;}
2902 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2903 template<typename V> bool decode(V& v)
2906 if(!v(ref_nested())) return false;
2907 { type = 1; return true;}
2911 template<typename V> bool encode(V& v) const
2913 return v(ref_nested());
2917 template<typename V> bool decode(size_t index, V& v)
2922 case 1: type = 1; return v(ref_nested());
2923 ref_nested().clear();
2928 template<typename V> bool encode(size_t index, V& v) const
2930 if(index != type) {return false;} return v(ref_nested());
2937 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2939 size_t get_index() const {return type;}
2940 bool is_unknown() const { return type == 1; }
2941 void clear() {type = 0;}
2942 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2943 template<typename V> bool decode(V& v)
2946 if(!v(ref_nested())) return false;
2947 { type = 1; return true;}
2951 template<typename V> bool encode(V& v) const
2953 return v(ref_nested());
2957 template<typename V> bool decode(size_t index, V& v)
2962 case 1: type = 1; return v(ref_nested());
2963 ref_nested().clear();
2968 template<typename V> bool encode(size_t index, V& v) const
2970 if(index != type) {return false;} return v(ref_nested());
2977 struct Extension_t : asn::typefield<true>
2979 ~Extension_t() {clear();}
2980 size_t get_index() const {return type;}
2981 bool is_unknown() const { return type == 1; }
2984 type = 0; ref_nested().clear();
2986 template<typename V> static inline void enumerate(V& v)
2991 template<typename V> bool decode(size_t index, V& v)
2996 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3001 template<typename V> bool encode(size_t index, V& v) const
3003 if(index != type) return false;
3011 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3013 size_t get_index() const {return type;}
3014 bool is_unknown() const { return type == 1; }
3015 void clear() {type = 0;}
3016 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3017 template<typename V> bool decode(V& v)
3020 if(!v(ref_nested())) return false;
3021 { type = 1; return true;}
3025 template<typename V> bool encode(V& v) const
3027 return v(ref_nested());
3031 template<typename V> bool decode(size_t index, V& v)
3036 case 1: type = 1; return v(ref_nested());
3037 ref_nested().clear();
3042 template<typename V> bool encode(size_t index, V& v) const
3044 if(index != type) {return false;} return v(ref_nested());
3054 CellToReport-Item ::= SEQUENCE {
3056 iE-Extensions ProtocolExtensionContainer { {CellToReport-Item-ExtIEs} } OPTIONAL,
3061 struct CellToReport_Item : asn::sequence<2, 0, true, 1>
3063 static constexpr const char* name() {return "CellToReport-Item";}
3064 using parent_t = asn::sequence<2, 0, true, 1>;
3065 struct cell_ID_t : ECGI
3067 static constexpr const char* name() {return "cell_ID_t";}
3068 using parent_t = ECGI;
3071 cell_ID_t& ref_cell_ID() {return cell_ID;}
3072 cell_ID_t const& ref_cell_ID() const {return cell_ID;}
3073 struct iE_Extensions_t : ProtocolExtensionContainer<CellToReport_Item_ExtIEs>
3075 static constexpr const char* name() {return "iE_Extensions_t";}
3076 using parent_t = ProtocolExtensionContainer<CellToReport_Item_ExtIEs>;
3077 static constexpr bool optional = true;
3080 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3081 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3082 template<typename V> void decode(V& v)
3088 template<typename V> void encode(V& v) const
3097 iE_Extensions.clear();
3102 iE_Extensions_t iE_Extensions;
3106 CellToReport-ItemIEs X2AP-PROTOCOL-IES ::= {
3107 { ID id-CellToReport-Item CRITICALITY ignore TYPE CellToReport-Item PRESENCE mandatory}
3111 struct CellToReport_ItemIEs
3113 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3115 size_t get_index() const {return type;}
3116 void clear() {type = 0;}
3117 void select_id_CellToReport_Item() { set(id_CellToReport_Item); type=1;}
3118 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3119 template<typename V> bool decode(V& v)
3122 if(!v(ref_nested())) return false;
3123 if(equal(id_CellToReport_Item)) { type = 1; return true; }
3127 template<typename V> bool encode(V& v) const
3129 return v(ref_nested());
3133 template<typename V> bool decode(size_t index, V& v)
3138 case 1: type = 1; if(v(ref_nested())) { return equal(id_CellToReport_Item);} return false;
3139 ref_nested().clear();
3144 template<typename V> bool encode(size_t index, V& v) const
3146 if(index != type) {return false;} return v(ref_nested());
3153 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
3155 size_t get_index() const {return type;}
3156 void clear() {type = 0;}
3157 void select_id_CellToReport_Item() { set(ignore); type=1;}
3158 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
3159 template<typename V> bool decode(V& v)
3162 if(!v(ref_nested())) return false;
3163 if(equal(ignore)) { type = 1; return true; }
3167 template<typename V> bool encode(V& v) const
3169 return v(ref_nested());
3173 template<typename V> bool decode(size_t index, V& v)
3178 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
3179 ref_nested().clear();
3184 template<typename V> bool encode(size_t index, V& v) const
3186 if(index != type) {return false;} return v(ref_nested());
3193 struct Value_t : asn::typefield<false>
3195 ~Value_t() {clear();}
3196 size_t get_index() const {return type;}
3197 CellToReport_Item& select_id_CellToReport_Item() { return set<CellToReport_Item>(1); }
3198 CellToReport_Item const* get_id_CellToReport_Item() const { return get<CellToReport_Item>(1); }
3203 case 1: var.destroy<CellToReport_Item>(); break;
3205 type = 0; ref_nested().clear();
3207 template<typename V> static inline void enumerate(V& v)
3209 v.template operator()<CellToReport_Item>(1);
3213 template<typename V> bool decode(size_t index, V& v)
3218 case 1: v(select_id_CellToReport_Item()); return true;
3223 template<typename V> bool encode(size_t index, V& v) const
3225 if(index != type) return false;
3228 case 1: v(var.as<CellToReport_Item>()); return true;
3234 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
3235 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
3238 char dummy1[sizeof(CellToReport_Item)];
3241 asn::variant<sizeof(union_type)> var;
3245 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
3247 size_t get_index() const {return type;}
3248 void clear() {type = 0;}
3249 void select_id_CellToReport_Item() { set(mandatory); type=1;}
3250 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
3251 template<typename V> bool decode(V& v)
3254 if(!v(ref_nested())) return false;
3255 if(equal(mandatory)) { type = 1; return true; }
3259 template<typename V> bool encode(V& v) const
3261 return v(ref_nested());
3265 template<typename V> bool decode(size_t index, V& v)
3270 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
3271 ref_nested().clear();
3276 template<typename V> bool encode(size_t index, V& v) const
3278 if(index != type) {return false;} return v(ref_nested());
3288 CellToReport-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellToReport-ItemIEs} }
3291 struct CellToReport_List_elm : ProtocolIE_Single_Container<CellToReport_ItemIEs>
3293 static constexpr const char* name() {return "CellToReport_List_elm";}
3294 using parent_t = ProtocolIE_Single_Container<CellToReport_ItemIEs>;
3297 struct CellToReport_List : asn::sequenceof<CellToReport_List_elm>
3299 static constexpr const char* name() {return "CellToReport-List";}
3300 using parent_t = asn::sequenceof<CellToReport_List_elm>;
3301 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
3305 MeasurementFailureCause-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3310 struct MeasurementFailureCause_Item_ExtIEs
3312 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3314 size_t get_index() const {return type;}
3315 bool is_unknown() const { return type == 1; }
3316 void clear() {type = 0;}
3317 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3318 template<typename V> bool decode(V& v)
3321 if(!v(ref_nested())) return false;
3322 { type = 1; return true;}
3326 template<typename V> bool encode(V& v) const
3328 return v(ref_nested());
3332 template<typename V> bool decode(size_t index, V& v)
3337 case 1: type = 1; return v(ref_nested());
3338 ref_nested().clear();
3343 template<typename V> bool encode(size_t index, V& v) const
3345 if(index != type) {return false;} return v(ref_nested());
3352 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3354 size_t get_index() const {return type;}
3355 bool is_unknown() const { return type == 1; }
3356 void clear() {type = 0;}
3357 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3358 template<typename V> bool decode(V& v)
3361 if(!v(ref_nested())) return false;
3362 { type = 1; return true;}
3366 template<typename V> bool encode(V& v) const
3368 return v(ref_nested());
3372 template<typename V> bool decode(size_t index, V& v)
3377 case 1: type = 1; return v(ref_nested());
3378 ref_nested().clear();
3383 template<typename V> bool encode(size_t index, V& v) const
3385 if(index != type) {return false;} return v(ref_nested());
3392 struct Extension_t : asn::typefield<true>
3394 ~Extension_t() {clear();}
3395 size_t get_index() const {return type;}
3396 bool is_unknown() const { return type == 1; }
3399 type = 0; ref_nested().clear();
3401 template<typename V> static inline void enumerate(V& v)
3406 template<typename V> bool decode(size_t index, V& v)
3411 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3416 template<typename V> bool encode(size_t index, V& v) const
3418 if(index != type) return false;
3426 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3428 size_t get_index() const {return type;}
3429 bool is_unknown() const { return type == 1; }
3430 void clear() {type = 0;}
3431 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3432 template<typename V> bool decode(V& v)
3435 if(!v(ref_nested())) return false;
3436 { type = 1; return true;}
3440 template<typename V> bool encode(V& v) const
3442 return v(ref_nested());
3446 template<typename V> bool decode(size_t index, V& v)
3451 case 1: type = 1; return v(ref_nested());
3452 ref_nested().clear();
3457 template<typename V> bool encode(size_t index, V& v) const
3459 if(index != type) {return false;} return v(ref_nested());
3469 MeasurementFailureCause-Item ::= SEQUENCE {
3470 measurementFailedReportCharacteristics ReportCharacteristics,
3472 iE-Extensions ProtocolExtensionContainer { {MeasurementFailureCause-Item-ExtIEs} } OPTIONAL,
3477 struct MeasurementFailureCause_Item : asn::sequence<3, 0, true, 1>
3479 static constexpr const char* name() {return "MeasurementFailureCause-Item";}
3480 using parent_t = asn::sequence<3, 0, true, 1>;
3481 struct measurementFailedReportCharacteristics_t : ReportCharacteristics
3483 static constexpr const char* name() {return "measurementFailedReportCharacteristics_t";}
3484 using parent_t = ReportCharacteristics;
3487 measurementFailedReportCharacteristics_t& ref_measurementFailedReportCharacteristics() {return measurementFailedReportCharacteristics;}
3488 measurementFailedReportCharacteristics_t const& ref_measurementFailedReportCharacteristics() const {return measurementFailedReportCharacteristics;}
3489 struct cause_t : Cause
3491 static constexpr const char* name() {return "cause_t";}
3492 using parent_t = Cause;
3495 cause_t& ref_cause() {return cause;}
3496 cause_t const& ref_cause() const {return cause;}
3497 struct iE_Extensions_t : ProtocolExtensionContainer<MeasurementFailureCause_Item_ExtIEs>
3499 static constexpr const char* name() {return "iE_Extensions_t";}
3500 using parent_t = ProtocolExtensionContainer<MeasurementFailureCause_Item_ExtIEs>;
3501 static constexpr bool optional = true;
3504 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3505 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3506 template<typename V> void decode(V& v)
3508 v(measurementFailedReportCharacteristics);
3513 template<typename V> void encode(V& v) const
3515 v(measurementFailedReportCharacteristics);
3522 measurementFailedReportCharacteristics.clear();
3524 iE_Extensions.clear();
3528 measurementFailedReportCharacteristics_t measurementFailedReportCharacteristics;
3530 iE_Extensions_t iE_Extensions;
3534 MeasurementFailureCause-ItemIEs X2AP-PROTOCOL-IES ::= {
3535 { ID id-MeasurementFailureCause-Item CRITICALITY ignore TYPE MeasurementFailureCause-Item PRESENCE mandatory}
3539 struct MeasurementFailureCause_ItemIEs
3541 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3543 size_t get_index() const {return type;}
3544 void clear() {type = 0;}
3545 void select_id_MeasurementFailureCause_Item() { set(id_MeasurementFailureCause_Item); type=1;}
3546 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3547 template<typename V> bool decode(V& v)
3550 if(!v(ref_nested())) return false;
3551 if(equal(id_MeasurementFailureCause_Item)) { type = 1; return true; }
3555 template<typename V> bool encode(V& v) const
3557 return v(ref_nested());
3561 template<typename V> bool decode(size_t index, V& v)
3566 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeasurementFailureCause_Item);} return false;
3567 ref_nested().clear();
3572 template<typename V> bool encode(size_t index, V& v) const
3574 if(index != type) {return false;} return v(ref_nested());
3581 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
3583 size_t get_index() const {return type;}
3584 void clear() {type = 0;}
3585 void select_id_MeasurementFailureCause_Item() { set(ignore); type=1;}
3586 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
3587 template<typename V> bool decode(V& v)
3590 if(!v(ref_nested())) return false;
3591 if(equal(ignore)) { type = 1; return true; }
3595 template<typename V> bool encode(V& v) const
3597 return v(ref_nested());
3601 template<typename V> bool decode(size_t index, V& v)
3606 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
3607 ref_nested().clear();
3612 template<typename V> bool encode(size_t index, V& v) const
3614 if(index != type) {return false;} return v(ref_nested());
3621 struct Value_t : asn::typefield<false>
3623 ~Value_t() {clear();}
3624 size_t get_index() const {return type;}
3625 MeasurementFailureCause_Item& select_id_MeasurementFailureCause_Item() { return set<MeasurementFailureCause_Item>(1); }
3626 MeasurementFailureCause_Item const* get_id_MeasurementFailureCause_Item() const { return get<MeasurementFailureCause_Item>(1); }
3631 case 1: var.destroy<MeasurementFailureCause_Item>(); break;
3633 type = 0; ref_nested().clear();
3635 template<typename V> static inline void enumerate(V& v)
3637 v.template operator()<MeasurementFailureCause_Item>(1);
3641 template<typename V> bool decode(size_t index, V& v)
3646 case 1: v(select_id_MeasurementFailureCause_Item()); return true;
3651 template<typename V> bool encode(size_t index, V& v) const
3653 if(index != type) return false;
3656 case 1: v(var.as<MeasurementFailureCause_Item>()); return true;
3662 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
3663 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
3666 char dummy1[sizeof(MeasurementFailureCause_Item)];
3669 asn::variant<sizeof(union_type)> var;
3673 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
3675 size_t get_index() const {return type;}
3676 void clear() {type = 0;}
3677 void select_id_MeasurementFailureCause_Item() { set(mandatory); type=1;}
3678 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
3679 template<typename V> bool decode(V& v)
3682 if(!v(ref_nested())) return false;
3683 if(equal(mandatory)) { type = 1; return true; }
3687 template<typename V> bool encode(V& v) const
3689 return v(ref_nested());
3693 template<typename V> bool decode(size_t index, V& v)
3698 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
3699 ref_nested().clear();
3704 template<typename V> bool encode(size_t index, V& v) const
3706 if(index != type) {return false;} return v(ref_nested());
3716 MeasurementFailureCause-List ::= SEQUENCE (SIZE (1..maxFailedMeasObjects)) OF ProtocolIE-Single-Container { {MeasurementFailureCause-ItemIEs} }
3719 struct MeasurementFailureCause_List_elm : ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>
3721 static constexpr const char* name() {return "MeasurementFailureCause_List_elm";}
3722 using parent_t = ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>;
3725 struct MeasurementFailureCause_List : asn::sequenceof<MeasurementFailureCause_List_elm>
3727 static constexpr const char* name() {return "MeasurementFailureCause-List";}
3728 using parent_t = asn::sequenceof<MeasurementFailureCause_List_elm>;
3729 using constraint_t = asn::constraints<false,asn::span<1, maxFailedMeasObjects >>;
3733 CompleteFailureCauseInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3738 struct CompleteFailureCauseInformation_Item_ExtIEs
3740 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3742 size_t get_index() const {return type;}
3743 bool is_unknown() const { return type == 1; }
3744 void clear() {type = 0;}
3745 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3746 template<typename V> bool decode(V& v)
3749 if(!v(ref_nested())) return false;
3750 { type = 1; return true;}
3754 template<typename V> bool encode(V& v) const
3756 return v(ref_nested());
3760 template<typename V> bool decode(size_t index, V& v)
3765 case 1: type = 1; return v(ref_nested());
3766 ref_nested().clear();
3771 template<typename V> bool encode(size_t index, V& v) const
3773 if(index != type) {return false;} return v(ref_nested());
3780 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3782 size_t get_index() const {return type;}
3783 bool is_unknown() const { return type == 1; }
3784 void clear() {type = 0;}
3785 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3786 template<typename V> bool decode(V& v)
3789 if(!v(ref_nested())) return false;
3790 { type = 1; return true;}
3794 template<typename V> bool encode(V& v) const
3796 return v(ref_nested());
3800 template<typename V> bool decode(size_t index, V& v)
3805 case 1: type = 1; return v(ref_nested());
3806 ref_nested().clear();
3811 template<typename V> bool encode(size_t index, V& v) const
3813 if(index != type) {return false;} return v(ref_nested());
3820 struct Extension_t : asn::typefield<true>
3822 ~Extension_t() {clear();}
3823 size_t get_index() const {return type;}
3824 bool is_unknown() const { return type == 1; }
3827 type = 0; ref_nested().clear();
3829 template<typename V> static inline void enumerate(V& v)
3834 template<typename V> bool decode(size_t index, V& v)
3839 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3844 template<typename V> bool encode(size_t index, V& v) const
3846 if(index != type) return false;
3854 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_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::presence_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());
3897 CompleteFailureCauseInformation-Item ::= SEQUENCE {
3899 measurementFailureCause-List MeasurementFailureCause-List,
3900 iE-Extensions ProtocolExtensionContainer { {CompleteFailureCauseInformation-Item-ExtIEs} } OPTIONAL,
3905 struct CompleteFailureCauseInformation_Item : asn::sequence<3, 0, true, 1>
3907 static constexpr const char* name() {return "CompleteFailureCauseInformation-Item";}
3908 using parent_t = asn::sequence<3, 0, true, 1>;
3909 struct cell_ID_t : ECGI
3911 static constexpr const char* name() {return "cell_ID_t";}
3912 using parent_t = ECGI;
3915 cell_ID_t& ref_cell_ID() {return cell_ID;}
3916 cell_ID_t const& ref_cell_ID() const {return cell_ID;}
3917 struct measurementFailureCause_List_t : MeasurementFailureCause_List
3919 static constexpr const char* name() {return "measurementFailureCause_List_t";}
3920 using parent_t = MeasurementFailureCause_List;
3923 measurementFailureCause_List_t& ref_measurementFailureCause_List() {return measurementFailureCause_List;}
3924 measurementFailureCause_List_t const& ref_measurementFailureCause_List() const {return measurementFailureCause_List;}
3925 struct iE_Extensions_t : ProtocolExtensionContainer<CompleteFailureCauseInformation_Item_ExtIEs>
3927 static constexpr const char* name() {return "iE_Extensions_t";}
3928 using parent_t = ProtocolExtensionContainer<CompleteFailureCauseInformation_Item_ExtIEs>;
3929 static constexpr bool optional = true;
3932 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3933 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3934 template<typename V> void decode(V& v)
3937 v(measurementFailureCause_List);
3941 template<typename V> void encode(V& v) const
3944 v(measurementFailureCause_List);
3951 measurementFailureCause_List.clear();
3952 iE_Extensions.clear();
3957 measurementFailureCause_List_t measurementFailureCause_List;
3958 iE_Extensions_t iE_Extensions;
3962 CompleteFailureCauseInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
3963 { ID id-CompleteFailureCauseInformation-Item CRITICALITY ignore TYPE CompleteFailureCauseInformation-Item PRESENCE mandatory}
3967 struct CompleteFailureCauseInformation_ItemIEs
3969 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3971 size_t get_index() const {return type;}
3972 void clear() {type = 0;}
3973 void select_id_CompleteFailureCauseInformation_Item() { set(id_CompleteFailureCauseInformation_Item); type=1;}
3974 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3975 template<typename V> bool decode(V& v)
3978 if(!v(ref_nested())) return false;
3979 if(equal(id_CompleteFailureCauseInformation_Item)) { type = 1; return true; }
3983 template<typename V> bool encode(V& v) const
3985 return v(ref_nested());
3989 template<typename V> bool decode(size_t index, V& v)
3994 case 1: type = 1; if(v(ref_nested())) { return equal(id_CompleteFailureCauseInformation_Item);} return false;
3995 ref_nested().clear();
4000 template<typename V> bool encode(size_t index, V& v) const
4002 if(index != type) {return false;} return v(ref_nested());
4009 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
4011 size_t get_index() const {return type;}
4012 void clear() {type = 0;}
4013 void select_id_CompleteFailureCauseInformation_Item() { set(ignore); type=1;}
4014 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4015 template<typename V> bool decode(V& v)
4018 if(!v(ref_nested())) return false;
4019 if(equal(ignore)) { type = 1; return true; }
4023 template<typename V> bool encode(V& v) const
4025 return v(ref_nested());
4029 template<typename V> bool decode(size_t index, V& v)
4034 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4035 ref_nested().clear();
4040 template<typename V> bool encode(size_t index, V& v) const
4042 if(index != type) {return false;} return v(ref_nested());
4049 struct Value_t : asn::typefield<false>
4051 ~Value_t() {clear();}
4052 size_t get_index() const {return type;}
4053 CompleteFailureCauseInformation_Item& select_id_CompleteFailureCauseInformation_Item() { return set<CompleteFailureCauseInformation_Item>(1); }
4054 CompleteFailureCauseInformation_Item const* get_id_CompleteFailureCauseInformation_Item() const { return get<CompleteFailureCauseInformation_Item>(1); }
4059 case 1: var.destroy<CompleteFailureCauseInformation_Item>(); break;
4061 type = 0; ref_nested().clear();
4063 template<typename V> static inline void enumerate(V& v)
4065 v.template operator()<CompleteFailureCauseInformation_Item>(1);
4069 template<typename V> bool decode(size_t index, V& v)
4074 case 1: v(select_id_CompleteFailureCauseInformation_Item()); return true;
4079 template<typename V> bool encode(size_t index, V& v) const
4081 if(index != type) return false;
4084 case 1: v(var.as<CompleteFailureCauseInformation_Item>()); return true;
4090 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4091 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4094 char dummy1[sizeof(CompleteFailureCauseInformation_Item)];
4097 asn::variant<sizeof(union_type)> var;
4101 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
4103 size_t get_index() const {return type;}
4104 void clear() {type = 0;}
4105 void select_id_CompleteFailureCauseInformation_Item() { set(mandatory); type=1;}
4106 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4107 template<typename V> bool decode(V& v)
4110 if(!v(ref_nested())) return false;
4111 if(equal(mandatory)) { type = 1; return true; }
4115 template<typename V> bool encode(V& v) const
4117 return v(ref_nested());
4121 template<typename V> bool decode(size_t index, V& v)
4126 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
4127 ref_nested().clear();
4132 template<typename V> bool encode(size_t index, V& v) const
4134 if(index != type) {return false;} return v(ref_nested());
4144 CompleteFailureCauseInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CompleteFailureCauseInformation-ItemIEs} }
4147 struct CompleteFailureCauseInformation_List_elm : ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>
4149 static constexpr const char* name() {return "CompleteFailureCauseInformation_List_elm";}
4150 using parent_t = ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>;
4153 struct CompleteFailureCauseInformation_List : asn::sequenceof<CompleteFailureCauseInformation_List_elm>
4155 static constexpr const char* name() {return "CompleteFailureCauseInformation-List";}
4156 using parent_t = asn::sequenceof<CompleteFailureCauseInformation_List_elm>;
4157 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
4161 E-RABs-DataForwardingAddress-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4166 struct E_RABs_DataForwardingAddress_ItemExtIEs
4168 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4170 size_t get_index() const {return type;}
4171 bool is_unknown() const { return type == 1; }
4172 void clear() {type = 0;}
4173 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4174 template<typename V> bool decode(V& v)
4177 if(!v(ref_nested())) return false;
4178 { type = 1; return true;}
4182 template<typename V> bool encode(V& v) const
4184 return v(ref_nested());
4188 template<typename V> bool decode(size_t index, V& v)
4193 case 1: type = 1; return v(ref_nested());
4194 ref_nested().clear();
4199 template<typename V> bool encode(size_t index, V& v) const
4201 if(index != type) {return false;} return v(ref_nested());
4208 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4210 size_t get_index() const {return type;}
4211 bool is_unknown() const { return type == 1; }
4212 void clear() {type = 0;}
4213 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4214 template<typename V> bool decode(V& v)
4217 if(!v(ref_nested())) return false;
4218 { type = 1; return true;}
4222 template<typename V> bool encode(V& v) const
4224 return v(ref_nested());
4228 template<typename V> bool decode(size_t index, V& v)
4233 case 1: type = 1; return v(ref_nested());
4234 ref_nested().clear();
4239 template<typename V> bool encode(size_t index, V& v) const
4241 if(index != type) {return false;} return v(ref_nested());
4248 struct Extension_t : asn::typefield<true>
4250 ~Extension_t() {clear();}
4251 size_t get_index() const {return type;}
4252 bool is_unknown() const { return type == 1; }
4255 type = 0; ref_nested().clear();
4257 template<typename V> static inline void enumerate(V& v)
4262 template<typename V> bool decode(size_t index, V& v)
4267 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4272 template<typename V> bool encode(size_t index, V& v) const
4274 if(index != type) return false;
4282 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4284 size_t get_index() const {return type;}
4285 bool is_unknown() const { return type == 1; }
4286 void clear() {type = 0;}
4287 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4288 template<typename V> bool decode(V& v)
4291 if(!v(ref_nested())) return false;
4292 { type = 1; return true;}
4296 template<typename V> bool encode(V& v) const
4298 return v(ref_nested());
4302 template<typename V> bool decode(size_t index, V& v)
4307 case 1: type = 1; return v(ref_nested());
4308 ref_nested().clear();
4313 template<typename V> bool encode(size_t index, V& v) const
4315 if(index != type) {return false;} return v(ref_nested());
4325 E-RABs-DataForwardingAddress-Item ::= SEQUENCE {
4327 dl-GTPtunnelEndpoint GTPtunnelEndpoint,
4328 iE-Extensions ProtocolExtensionContainer { {E-RABs-DataForwardingAddress-ItemExtIEs} } OPTIONAL,
4333 struct E_RABs_DataForwardingAddress_Item : asn::sequence<3, 0, true, 1>
4335 static constexpr const char* name() {return "E-RABs-DataForwardingAddress-Item";}
4336 using parent_t = asn::sequence<3, 0, true, 1>;
4337 struct e_RAB_ID_t : E_RAB_ID
4339 static constexpr const char* name() {return "e_RAB_ID_t";}
4340 using parent_t = E_RAB_ID;
4343 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
4344 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
4345 struct dl_GTPtunnelEndpoint_t : GTPtunnelEndpoint
4347 static constexpr const char* name() {return "dl_GTPtunnelEndpoint_t";}
4348 using parent_t = GTPtunnelEndpoint;
4351 dl_GTPtunnelEndpoint_t& ref_dl_GTPtunnelEndpoint() {return dl_GTPtunnelEndpoint;}
4352 dl_GTPtunnelEndpoint_t const& ref_dl_GTPtunnelEndpoint() const {return dl_GTPtunnelEndpoint;}
4353 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>
4355 static constexpr const char* name() {return "iE_Extensions_t";}
4356 using parent_t = ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>;
4357 static constexpr bool optional = true;
4360 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4361 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4362 template<typename V> void decode(V& v)
4365 v(dl_GTPtunnelEndpoint);
4369 template<typename V> void encode(V& v) const
4372 v(dl_GTPtunnelEndpoint);
4379 dl_GTPtunnelEndpoint.clear();
4380 iE_Extensions.clear();
4384 e_RAB_ID_t e_RAB_ID;
4385 dl_GTPtunnelEndpoint_t dl_GTPtunnelEndpoint;
4386 iE_Extensions_t iE_Extensions;
4390 E-RABs-DataForwardingAddress-ItemIEs X2AP-PROTOCOL-IES ::= {
4391 { ID id-E-RABs-DataForwardingAddress-Item CRITICALITY ignore TYPE E-RABs-DataForwardingAddress-Item PRESENCE mandatory},
4396 struct E_RABs_DataForwardingAddress_ItemIEs
4398 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
4400 size_t get_index() const {return type;}
4401 bool is_unknown() const { return type == 2; }
4402 void clear() {type = 0;}
4403 void select_id_E_RABs_DataForwardingAddress_Item() { set(id_E_RABs_DataForwardingAddress_Item); type=1;}
4404 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
4405 template<typename V> bool decode(V& v)
4408 if(!v(ref_nested())) return false;
4409 if(equal(id_E_RABs_DataForwardingAddress_Item)) { type = 1; return true; }
4410 else { type = 2; return true;}
4414 template<typename V> bool encode(V& v) const
4416 return v(ref_nested());
4420 template<typename V> bool decode(size_t index, V& v)
4425 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_DataForwardingAddress_Item);} return false;
4426 case 2: type = 2; return v(ref_nested());
4427 ref_nested().clear();
4432 template<typename V> bool encode(size_t index, V& v) const
4434 if(index != type) {return false;} return v(ref_nested());
4441 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
4443 size_t get_index() const {return type;}
4444 bool is_unknown() const { return type == 2; }
4445 void clear() {type = 0;}
4446 void select_id_E_RABs_DataForwardingAddress_Item() { set(ignore); type=1;}
4447 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4448 template<typename V> bool decode(V& v)
4451 if(!v(ref_nested())) return false;
4452 if(equal(ignore)) { type = 1; return true; }
4453 else { type = 2; return true;}
4457 template<typename V> bool encode(V& v) const
4459 return v(ref_nested());
4463 template<typename V> bool decode(size_t index, V& v)
4468 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4469 case 2: type = 2; return v(ref_nested());
4470 ref_nested().clear();
4475 template<typename V> bool encode(size_t index, V& v) const
4477 if(index != type) {return false;} return v(ref_nested());
4484 struct Value_t : asn::typefield<true>
4486 ~Value_t() {clear();}
4487 size_t get_index() const {return type;}
4488 E_RABs_DataForwardingAddress_Item& select_id_E_RABs_DataForwardingAddress_Item() { return set<E_RABs_DataForwardingAddress_Item>(1); }
4489 E_RABs_DataForwardingAddress_Item const* get_id_E_RABs_DataForwardingAddress_Item() const { return get<E_RABs_DataForwardingAddress_Item>(1); }
4490 bool is_unknown() const { return type == 2; }
4495 case 1: var.destroy<E_RABs_DataForwardingAddress_Item>(); break;
4497 type = 0; ref_nested().clear();
4499 template<typename V> static inline void enumerate(V& v)
4501 v.template operator()<E_RABs_DataForwardingAddress_Item>(1);
4505 template<typename V> bool decode(size_t index, V& v)
4510 case 1: v(select_id_E_RABs_DataForwardingAddress_Item()); return true;
4511 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
4516 template<typename V> bool encode(size_t index, V& v) const
4518 if(index != type) return false;
4521 case 1: v(var.as<E_RABs_DataForwardingAddress_Item>()); return true;
4527 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4528 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4531 char dummy1[sizeof(E_RABs_DataForwardingAddress_Item)];
4534 asn::variant<sizeof(union_type)> var;
4538 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
4540 size_t get_index() const {return type;}
4541 bool is_unknown() const { return type == 2; }
4542 void clear() {type = 0;}
4543 void select_id_E_RABs_DataForwardingAddress_Item() { set(mandatory); type=1;}
4544 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4545 template<typename V> bool decode(V& v)
4548 if(!v(ref_nested())) return false;
4549 if(equal(mandatory)) { type = 1; return true; }
4550 else { type = 2; return true;}
4554 template<typename V> bool encode(V& v) const
4556 return v(ref_nested());
4560 template<typename V> bool decode(size_t index, V& v)
4565 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
4566 case 2: type = 2; return v(ref_nested());
4567 ref_nested().clear();
4572 template<typename V> bool encode(size_t index, V& v) const
4574 if(index != type) {return false;} return v(ref_nested());
4584 E-RABs-DataForwardingAddress-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-DataForwardingAddress-ItemIEs} }
4587 struct E_RABs_DataForwardingAddress_List_elm : ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>
4589 static constexpr const char* name() {return "E_RABs_DataForwardingAddress_List_elm";}
4590 using parent_t = ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>;
4593 struct E_RABs_DataForwardingAddress_List : asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>
4595 static constexpr const char* name() {return "E-RABs-DataForwardingAddress-List";}
4596 using parent_t = asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>;
4597 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
4601 DataForwardingAddressIndication-IEs X2AP-PROTOCOL-IES ::= {
4602 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional }|
4603 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
4604 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional }|
4605 { ID id-E-RABs-DataForwardingAddress-List CRITICALITY ignore TYPE E-RABs-DataForwardingAddress-List PRESENCE mandatory},
4610 struct DataForwardingAddressIndication_IEs
4612 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
4614 size_t get_index() const {return type;}
4615 bool is_unknown() const { return type == 5; }
4616 void clear() {type = 0;}
4617 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=1;}
4618 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=2;}
4619 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
4620 void select_id_E_RABs_DataForwardingAddress_List() { set(id_E_RABs_DataForwardingAddress_List); type=4;}
4621 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
4622 template<typename V> bool decode(V& v)
4625 if(!v(ref_nested())) return false;
4626 if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 1; return true; }
4627 else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 2; return true; }
4628 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
4629 else if(equal(id_E_RABs_DataForwardingAddress_List)) { type = 4; return true; }
4630 else { type = 5; return true;}
4634 template<typename V> bool encode(V& v) const
4636 return v(ref_nested());
4640 template<typename V> bool decode(size_t index, V& v)
4645 case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
4646 case 2: type = 2; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
4647 case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
4648 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_DataForwardingAddress_List);} return false;
4649 case 5: type = 5; return v(ref_nested());
4650 ref_nested().clear();
4655 template<typename V> bool encode(size_t index, V& v) const
4657 if(index != type) {return false;} return v(ref_nested());
4664 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
4666 size_t get_index() const {return type;}
4667 bool is_unknown() const { return type == 5; }
4668 void clear() {type = 0;}
4669 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=1;}
4670 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=2;}
4671 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=3;}
4672 void select_id_E_RABs_DataForwardingAddress_List() { set(ignore); type=4;}
4673 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4674 template<typename V> bool decode(V& v)
4677 if(!v(ref_nested())) return false;
4678 if(equal(ignore)) { type = 1; return true; }
4679 else if(equal(ignore)) { type = 2; return true; }
4680 else if(equal(ignore)) { type = 3; return true; }
4681 else if(equal(ignore)) { type = 4; return true; }
4682 else { type = 5; return true;}
4686 template<typename V> bool encode(V& v) const
4688 return v(ref_nested());
4692 template<typename V> bool decode(size_t index, V& v)
4697 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4698 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
4699 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
4700 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
4701 case 5: type = 5; return v(ref_nested());
4702 ref_nested().clear();
4707 template<typename V> bool encode(size_t index, V& v) const
4709 if(index != type) {return false;} return v(ref_nested());
4716 struct Value_t : asn::typefield<true>
4718 ~Value_t() {clear();}
4719 size_t get_index() const {return type;}
4720 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(1); }
4721 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(1); }
4722 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
4723 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
4724 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
4725 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
4726 E_RABs_DataForwardingAddress_List& select_id_E_RABs_DataForwardingAddress_List() { return set<E_RABs_DataForwardingAddress_List>(4); }
4727 E_RABs_DataForwardingAddress_List const* get_id_E_RABs_DataForwardingAddress_List() const { return get<E_RABs_DataForwardingAddress_List>(4); }
4728 bool is_unknown() const { return type == 5; }
4733 case 1: var.destroy<UE_X2AP_ID_Extension>(); break;
4734 case 2: var.destroy<UE_X2AP_ID>(); break;
4735 case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
4736 case 4: var.destroy<E_RABs_DataForwardingAddress_List>(); break;
4738 type = 0; ref_nested().clear();
4740 template<typename V> static inline void enumerate(V& v)
4742 v.template operator()<UE_X2AP_ID_Extension>(1);
4743 v.template operator()<UE_X2AP_ID>(2);
4744 v.template operator()<UE_X2AP_ID_Extension>(3);
4745 v.template operator()<E_RABs_DataForwardingAddress_List>(4);
4749 template<typename V> bool decode(size_t index, V& v)
4754 case 1: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
4755 case 2: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
4756 case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
4757 case 4: v(select_id_E_RABs_DataForwardingAddress_List()); return true;
4758 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
4763 template<typename V> bool encode(size_t index, V& v) const
4765 if(index != type) return false;
4768 case 1: v(var.as<UE_X2AP_ID_Extension>()); return true;
4769 case 2: v(var.as<UE_X2AP_ID>()); return true;
4770 case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
4771 case 4: v(var.as<E_RABs_DataForwardingAddress_List>()); return true;
4777 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4778 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4781 char dummy1[sizeof(E_RABs_DataForwardingAddress_List)];
4782 char dummy2[sizeof(UE_X2AP_ID)];
4783 char dummy3[sizeof(UE_X2AP_ID_Extension)];
4786 asn::variant<sizeof(union_type)> var;
4790 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
4792 size_t get_index() const {return type;}
4793 bool is_unknown() const { return type == 5; }
4794 void clear() {type = 0;}
4795 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=1;}
4796 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
4797 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
4798 void select_id_E_RABs_DataForwardingAddress_List() { set(mandatory); type=4;}
4799 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4800 template<typename V> bool decode(V& v)
4803 if(!v(ref_nested())) return false;
4804 if(equal(optional)) { type = 1; return true; }
4805 else if(equal(mandatory)) { type = 2; return true; }
4806 else if(equal(optional)) { type = 3; return true; }
4807 else if(equal(mandatory)) { type = 4; return true; }
4808 else { type = 5; return true;}
4812 template<typename V> bool encode(V& v) const
4814 return v(ref_nested());
4818 template<typename V> bool decode(size_t index, V& v)
4823 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
4824 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
4825 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
4826 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
4827 case 5: type = 5; return v(ref_nested());
4828 ref_nested().clear();
4833 template<typename V> bool encode(size_t index, V& v) const
4835 if(index != type) {return false;} return v(ref_nested());
4845 DataForwardingAddressIndication ::= SEQUENCE {
4846 protocolIEs ProtocolIE-Container {{DataForwardingAddressIndication-IEs}},
4851 struct DataForwardingAddressIndication : asn::sequence<1, 0, true, 0>
4853 static constexpr const char* name() {return "DataForwardingAddressIndication";}
4854 using parent_t = asn::sequence<1, 0, true, 0>;
4855 struct protocolIEs_t : ProtocolIE_Container<DataForwardingAddressIndication_IEs>
4857 static constexpr const char* name() {return "protocolIEs_t";}
4858 using parent_t = ProtocolIE_Container<DataForwardingAddressIndication_IEs>;
4861 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
4862 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
4863 template<typename V> void decode(V& v)
4868 template<typename V> void encode(V& v) const
4875 protocolIEs.clear();
4879 protocolIEs_t protocolIEs;
4883 E-RABs-Admitted-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4888 struct E_RABs_Admitted_Item_ExtIEs
4890 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4892 size_t get_index() const {return type;}
4893 bool is_unknown() const { return type == 1; }
4894 void clear() {type = 0;}
4895 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4896 template<typename V> bool decode(V& v)
4899 if(!v(ref_nested())) return false;
4900 { type = 1; return true;}
4904 template<typename V> bool encode(V& v) const
4906 return v(ref_nested());
4910 template<typename V> bool decode(size_t index, V& v)
4915 case 1: type = 1; return v(ref_nested());
4916 ref_nested().clear();
4921 template<typename V> bool encode(size_t index, V& v) const
4923 if(index != type) {return false;} return v(ref_nested());
4930 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4932 size_t get_index() const {return type;}
4933 bool is_unknown() const { return type == 1; }
4934 void clear() {type = 0;}
4935 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4936 template<typename V> bool decode(V& v)
4939 if(!v(ref_nested())) return false;
4940 { type = 1; return true;}
4944 template<typename V> bool encode(V& v) const
4946 return v(ref_nested());
4950 template<typename V> bool decode(size_t index, V& v)
4955 case 1: type = 1; return v(ref_nested());
4956 ref_nested().clear();
4961 template<typename V> bool encode(size_t index, V& v) const
4963 if(index != type) {return false;} return v(ref_nested());
4970 struct Extension_t : asn::typefield<true>
4972 ~Extension_t() {clear();}
4973 size_t get_index() const {return type;}
4974 bool is_unknown() const { return type == 1; }
4977 type = 0; ref_nested().clear();
4979 template<typename V> static inline void enumerate(V& v)
4984 template<typename V> bool decode(size_t index, V& v)
4989 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4994 template<typename V> bool encode(size_t index, V& v) const
4996 if(index != type) return false;
5004 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5006 size_t get_index() const {return type;}
5007 bool is_unknown() const { return type == 1; }
5008 void clear() {type = 0;}
5009 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5010 template<typename V> bool decode(V& v)
5013 if(!v(ref_nested())) return false;
5014 { type = 1; return true;}
5018 template<typename V> bool encode(V& v) const
5020 return v(ref_nested());
5024 template<typename V> bool decode(size_t index, V& v)
5029 case 1: type = 1; return v(ref_nested());
5030 ref_nested().clear();
5035 template<typename V> bool encode(size_t index, V& v) const
5037 if(index != type) {return false;} return v(ref_nested());
5047 E-RABs-Admitted-Item ::= SEQUENCE {
5049 uL-GTP-TunnelEndpoint GTPtunnelEndpoint OPTIONAL,
5050 dL-GTP-TunnelEndpoint GTPtunnelEndpoint OPTIONAL,
5051 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-Item-ExtIEs} } OPTIONAL,
5056 struct E_RABs_Admitted_Item : asn::sequence<4, 0, true, 3>
5058 static constexpr const char* name() {return "E-RABs-Admitted-Item";}
5059 using parent_t = asn::sequence<4, 0, true, 3>;
5060 struct e_RAB_ID_t : E_RAB_ID
5062 static constexpr const char* name() {return "e_RAB_ID_t";}
5063 using parent_t = E_RAB_ID;
5066 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5067 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5068 struct uL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
5070 static constexpr const char* name() {return "uL_GTP_TunnelEndpoint_t";}
5071 using parent_t = GTPtunnelEndpoint;
5072 static constexpr bool optional = true;
5075 uL_GTP_TunnelEndpoint_t& set_uL_GTP_TunnelEndpoint() { uL_GTP_TunnelEndpoint.setpresent(true); return uL_GTP_TunnelEndpoint;}
5076 uL_GTP_TunnelEndpoint_t const* get_uL_GTP_TunnelEndpoint() const {return uL_GTP_TunnelEndpoint.is_valid() ? &uL_GTP_TunnelEndpoint : nullptr;}
5077 struct dL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
5079 static constexpr const char* name() {return "dL_GTP_TunnelEndpoint_t";}
5080 using parent_t = GTPtunnelEndpoint;
5081 static constexpr bool optional = true;
5084 dL_GTP_TunnelEndpoint_t& set_dL_GTP_TunnelEndpoint() { dL_GTP_TunnelEndpoint.setpresent(true); return dL_GTP_TunnelEndpoint;}
5085 dL_GTP_TunnelEndpoint_t const* get_dL_GTP_TunnelEndpoint() const {return dL_GTP_TunnelEndpoint.is_valid() ? &dL_GTP_TunnelEndpoint : nullptr;}
5086 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_Item_ExtIEs>
5088 static constexpr const char* name() {return "iE_Extensions_t";}
5089 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_Item_ExtIEs>;
5090 static constexpr bool optional = true;
5093 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5094 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5095 template<typename V> void decode(V& v)
5098 v(uL_GTP_TunnelEndpoint);
5099 v(dL_GTP_TunnelEndpoint);
5103 template<typename V> void encode(V& v) const
5106 v(uL_GTP_TunnelEndpoint);
5107 v(dL_GTP_TunnelEndpoint);
5114 uL_GTP_TunnelEndpoint.clear();
5115 dL_GTP_TunnelEndpoint.clear();
5116 iE_Extensions.clear();
5120 e_RAB_ID_t e_RAB_ID;
5121 uL_GTP_TunnelEndpoint_t uL_GTP_TunnelEndpoint;
5122 dL_GTP_TunnelEndpoint_t dL_GTP_TunnelEndpoint;
5123 iE_Extensions_t iE_Extensions;
5127 E-RABs-Admitted-ItemIEs X2AP-PROTOCOL-IES ::= {
5128 { ID id-E-RABs-Admitted-Item CRITICALITY ignore TYPE E-RABs-Admitted-Item PRESENCE mandatory }
5132 struct E_RABs_Admitted_ItemIEs
5134 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
5136 size_t get_index() const {return type;}
5137 void clear() {type = 0;}
5138 void select_id_E_RABs_Admitted_Item() { set(id_E_RABs_Admitted_Item); type=1;}
5139 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
5140 template<typename V> bool decode(V& v)
5143 if(!v(ref_nested())) return false;
5144 if(equal(id_E_RABs_Admitted_Item)) { type = 1; return true; }
5148 template<typename V> bool encode(V& v) const
5150 return v(ref_nested());
5154 template<typename V> bool decode(size_t index, V& v)
5159 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_Item);} return false;
5160 ref_nested().clear();
5165 template<typename V> bool encode(size_t index, V& v) const
5167 if(index != type) {return false;} return v(ref_nested());
5174 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
5176 size_t get_index() const {return type;}
5177 void clear() {type = 0;}
5178 void select_id_E_RABs_Admitted_Item() { set(ignore); type=1;}
5179 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
5180 template<typename V> bool decode(V& v)
5183 if(!v(ref_nested())) return false;
5184 if(equal(ignore)) { type = 1; return true; }
5188 template<typename V> bool encode(V& v) const
5190 return v(ref_nested());
5194 template<typename V> bool decode(size_t index, V& v)
5199 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
5200 ref_nested().clear();
5205 template<typename V> bool encode(size_t index, V& v) const
5207 if(index != type) {return false;} return v(ref_nested());
5214 struct Value_t : asn::typefield<false>
5216 ~Value_t() {clear();}
5217 size_t get_index() const {return type;}
5218 E_RABs_Admitted_Item& select_id_E_RABs_Admitted_Item() { return set<E_RABs_Admitted_Item>(1); }
5219 E_RABs_Admitted_Item const* get_id_E_RABs_Admitted_Item() const { return get<E_RABs_Admitted_Item>(1); }
5224 case 1: var.destroy<E_RABs_Admitted_Item>(); break;
5226 type = 0; ref_nested().clear();
5228 template<typename V> static inline void enumerate(V& v)
5230 v.template operator()<E_RABs_Admitted_Item>(1);
5234 template<typename V> bool decode(size_t index, V& v)
5239 case 1: v(select_id_E_RABs_Admitted_Item()); return true;
5244 template<typename V> bool encode(size_t index, V& v) const
5246 if(index != type) return false;
5249 case 1: v(var.as<E_RABs_Admitted_Item>()); return true;
5255 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
5256 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
5259 char dummy1[sizeof(E_RABs_Admitted_Item)];
5262 asn::variant<sizeof(union_type)> var;
5266 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
5268 size_t get_index() const {return type;}
5269 void clear() {type = 0;}
5270 void select_id_E_RABs_Admitted_Item() { set(mandatory); type=1;}
5271 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
5272 template<typename V> bool decode(V& v)
5275 if(!v(ref_nested())) return false;
5276 if(equal(mandatory)) { type = 1; return true; }
5280 template<typename V> bool encode(V& v) const
5282 return v(ref_nested());
5286 template<typename V> bool decode(size_t index, V& v)
5291 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
5292 ref_nested().clear();
5297 template<typename V> bool encode(size_t index, V& v) const
5299 if(index != type) {return false;} return v(ref_nested());
5309 E-RABs-Admitted-List ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ItemIEs} }
5312 struct E_RABs_Admitted_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>
5314 static constexpr const char* name() {return "E_RABs_Admitted_List_elm";}
5315 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>;
5318 struct E_RABs_Admitted_List : asn::sequenceof<E_RABs_Admitted_List_elm>
5320 static constexpr const char* name() {return "E-RABs-Admitted-List";}
5321 using parent_t = asn::sequenceof<E_RABs_Admitted_List_elm>;
5322 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
5326 E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5331 struct E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs
5333 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5335 size_t get_index() const {return type;}
5336 bool is_unknown() const { return type == 1; }
5337 void clear() {type = 0;}
5338 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5339 template<typename V> bool decode(V& v)
5342 if(!v(ref_nested())) return false;
5343 { type = 1; return true;}
5347 template<typename V> bool encode(V& v) const
5349 return v(ref_nested());
5353 template<typename V> bool decode(size_t index, V& v)
5358 case 1: type = 1; return v(ref_nested());
5359 ref_nested().clear();
5364 template<typename V> bool encode(size_t index, V& v) const
5366 if(index != type) {return false;} return v(ref_nested());
5373 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5375 size_t get_index() const {return type;}
5376 bool is_unknown() const { return type == 1; }
5377 void clear() {type = 0;}
5378 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5379 template<typename V> bool decode(V& v)
5382 if(!v(ref_nested())) return false;
5383 { type = 1; return true;}
5387 template<typename V> bool encode(V& v) const
5389 return v(ref_nested());
5393 template<typename V> bool decode(size_t index, V& v)
5398 case 1: type = 1; return v(ref_nested());
5399 ref_nested().clear();
5404 template<typename V> bool encode(size_t index, V& v) const
5406 if(index != type) {return false;} return v(ref_nested());
5413 struct Extension_t : asn::typefield<true>
5415 ~Extension_t() {clear();}
5416 size_t get_index() const {return type;}
5417 bool is_unknown() const { return type == 1; }
5420 type = 0; ref_nested().clear();
5422 template<typename V> static inline void enumerate(V& v)
5427 template<typename V> bool decode(size_t index, V& v)
5432 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5437 template<typename V> bool encode(size_t index, V& v) const
5439 if(index != type) return false;
5447 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5449 size_t get_index() const {return type;}
5450 bool is_unknown() const { return type == 1; }
5451 void clear() {type = 0;}
5452 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5453 template<typename V> bool decode(V& v)
5456 if(!v(ref_nested())) return false;
5457 { type = 1; return true;}
5461 template<typename V> bool encode(V& v) const
5463 return v(ref_nested());
5467 template<typename V> bool decode(size_t index, V& v)
5472 case 1: type = 1; return v(ref_nested());
5473 ref_nested().clear();
5478 template<typename V> bool encode(size_t index, V& v) const
5480 if(index != type) {return false;} return v(ref_nested());
5490 E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
5492 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint,
5493 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
5494 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
5495 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs} } OPTIONAL,
5500 struct E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 3>
5502 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer";}
5503 using parent_t = asn::sequence<5, 0, true, 3>;
5504 struct e_RAB_ID_t : E_RAB_ID
5506 static constexpr const char* name() {return "e_RAB_ID_t";}
5507 using parent_t = E_RAB_ID;
5510 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5511 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5512 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5514 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
5515 using parent_t = GTPtunnelEndpoint;
5518 s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
5519 s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
5520 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5522 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
5523 using parent_t = GTPtunnelEndpoint;
5524 static constexpr bool optional = true;
5527 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
5528 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
5529 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5531 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
5532 using parent_t = GTPtunnelEndpoint;
5533 static constexpr bool optional = true;
5536 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
5537 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
5538 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>
5540 static constexpr const char* name() {return "iE_Extensions_t";}
5541 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>;
5542 static constexpr bool optional = true;
5545 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5546 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5547 template<typename V> void decode(V& v)
5550 v(s1_DL_GTPtunnelEndpoint);
5551 v(dL_Forwarding_GTPtunnelEndpoint);
5552 v(uL_Forwarding_GTPtunnelEndpoint);
5556 template<typename V> void encode(V& v) const
5559 v(s1_DL_GTPtunnelEndpoint);
5560 v(dL_Forwarding_GTPtunnelEndpoint);
5561 v(uL_Forwarding_GTPtunnelEndpoint);
5568 s1_DL_GTPtunnelEndpoint.clear();
5569 dL_Forwarding_GTPtunnelEndpoint.clear();
5570 uL_Forwarding_GTPtunnelEndpoint.clear();
5571 iE_Extensions.clear();
5575 e_RAB_ID_t e_RAB_ID;
5576 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
5577 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
5578 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
5579 iE_Extensions_t iE_Extensions;
5583 E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5588 struct E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs
5590 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5592 size_t get_index() const {return type;}
5593 bool is_unknown() const { return type == 1; }
5594 void clear() {type = 0;}
5595 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5596 template<typename V> bool decode(V& v)
5599 if(!v(ref_nested())) return false;
5600 { type = 1; return true;}
5604 template<typename V> bool encode(V& v) const
5606 return v(ref_nested());
5610 template<typename V> bool decode(size_t index, V& v)
5615 case 1: type = 1; return v(ref_nested());
5616 ref_nested().clear();
5621 template<typename V> bool encode(size_t index, V& v) const
5623 if(index != type) {return false;} return v(ref_nested());
5630 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5632 size_t get_index() const {return type;}
5633 bool is_unknown() const { return type == 1; }
5634 void clear() {type = 0;}
5635 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5636 template<typename V> bool decode(V& v)
5639 if(!v(ref_nested())) return false;
5640 { type = 1; return true;}
5644 template<typename V> bool encode(V& v) const
5646 return v(ref_nested());
5650 template<typename V> bool decode(size_t index, V& v)
5655 case 1: type = 1; return v(ref_nested());
5656 ref_nested().clear();
5661 template<typename V> bool encode(size_t index, V& v) const
5663 if(index != type) {return false;} return v(ref_nested());
5670 struct Extension_t : asn::typefield<true>
5672 ~Extension_t() {clear();}
5673 size_t get_index() const {return type;}
5674 bool is_unknown() const { return type == 1; }
5677 type = 0; ref_nested().clear();
5679 template<typename V> static inline void enumerate(V& v)
5684 template<typename V> bool decode(size_t index, V& v)
5689 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5694 template<typename V> bool encode(size_t index, V& v) const
5696 if(index != type) return false;
5704 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5706 size_t get_index() const {return type;}
5707 bool is_unknown() const { return type == 1; }
5708 void clear() {type = 0;}
5709 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5710 template<typename V> bool decode(V& v)
5713 if(!v(ref_nested())) return false;
5714 { type = 1; return true;}
5718 template<typename V> bool encode(V& v) const
5720 return v(ref_nested());
5724 template<typename V> bool decode(size_t index, V& v)
5729 case 1: type = 1; return v(ref_nested());
5730 ref_nested().clear();
5735 template<typename V> bool encode(size_t index, V& v) const
5737 if(index != type) {return false;} return v(ref_nested());
5747 E-RABs-Admitted-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
5749 seNB-GTPtunnelEndpoint GTPtunnelEndpoint,
5750 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
5755 struct E_RABs_Admitted_ToBeAdded_Item_Split_Bearer : asn::sequence<3, 0, true, 1>
5757 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-Split-Bearer";}
5758 using parent_t = asn::sequence<3, 0, true, 1>;
5759 struct e_RAB_ID_t : E_RAB_ID
5761 static constexpr const char* name() {return "e_RAB_ID_t";}
5762 using parent_t = E_RAB_ID;
5765 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5766 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5767 struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5769 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
5770 using parent_t = GTPtunnelEndpoint;
5773 seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
5774 seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
5775 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>
5777 static constexpr const char* name() {return "iE_Extensions_t";}
5778 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>;
5779 static constexpr bool optional = true;
5782 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5783 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5784 template<typename V> void decode(V& v)
5787 v(seNB_GTPtunnelEndpoint);
5791 template<typename V> void encode(V& v) const
5794 v(seNB_GTPtunnelEndpoint);
5801 seNB_GTPtunnelEndpoint.clear();
5802 iE_Extensions.clear();
5806 e_RAB_ID_t e_RAB_ID;
5807 seNB_GTPtunnelEndpoint_t seNB_GTPtunnelEndpoint;
5808 iE_Extensions_t iE_Extensions;
5812 E-RABs-Admitted-ToBeAdded-Item ::= CHOICE {
5813 sCG-Bearer E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer,
5814 split-Bearer E-RABs-Admitted-ToBeAdded-Item-Split-Bearer,
5819 struct E_RABs_Admitted_ToBeAdded_Item : asn::choice<2, 0, true>
5821 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item";}
5822 using parent_t = asn::choice<2, 0, true>;
5823 index_type get_index() const {return index;}
5824 bool is_unknown() const {return index == 3;}
5825 void set_unknown() { set_index(3); }
5826 ~E_RABs_Admitted_ToBeAdded_Item() {clear();}
5827 struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer
5829 static constexpr const char* name() {return "sCG_Bearer_t";}
5830 using parent_t = E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer;
5833 struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_Split_Bearer
5835 static constexpr const char* name() {return "split_Bearer_t";}
5836 using parent_t = E_RABs_Admitted_ToBeAdded_Item_Split_Bearer;
5843 case 1: var.destroy<sCG_Bearer_t>(); break;
5844 case 2: var.destroy<split_Bearer_t>(); break;
5849 template<typename V> bool decode(size_t idx, V& v)
5854 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
5855 case 2: set_index(2); return v(var.build<split_Bearer_t>());
5860 template<typename V> bool encode(V& v) const
5864 case 1: return v(var.as<sCG_Bearer_t>());
5865 case 2: return v(var.as<split_Bearer_t>());
5869 template<typename V> static inline void enumerate(V& v)
5871 v.template operator()<sCG_Bearer_t>(1);
5872 v.template operator()<split_Bearer_t>(2);
5875 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
5876 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
5877 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
5878 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
5880 void set_index(index_type i) {index = i; base::set();}
5883 char dummy1[sizeof(sCG_Bearer_t)];
5884 char dummy2[sizeof(split_Bearer_t)];
5887 asn::variant<sizeof(union_type)> var;
5888 index_type index {0};
5891 E-RABs-Admitted-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
5892 { ID id-E-RABs-Admitted-ToBeAdded-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-Item PRESENCE mandatory}
5896 struct E_RABs_Admitted_ToBeAdded_ItemIEs
5898 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
5900 size_t get_index() const {return type;}
5901 void clear() {type = 0;}
5902 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(id_E_RABs_Admitted_ToBeAdded_Item); type=1;}
5903 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
5904 template<typename V> bool decode(V& v)
5907 if(!v(ref_nested())) return false;
5908 if(equal(id_E_RABs_Admitted_ToBeAdded_Item)) { type = 1; return true; }
5912 template<typename V> bool encode(V& v) const
5914 return v(ref_nested());
5918 template<typename V> bool decode(size_t index, V& v)
5923 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_Item);} return false;
5924 ref_nested().clear();
5929 template<typename V> bool encode(size_t index, V& v) const
5931 if(index != type) {return false;} return v(ref_nested());
5938 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
5940 size_t get_index() const {return type;}
5941 void clear() {type = 0;}
5942 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(ignore); type=1;}
5943 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
5944 template<typename V> bool decode(V& v)
5947 if(!v(ref_nested())) return false;
5948 if(equal(ignore)) { type = 1; return true; }
5952 template<typename V> bool encode(V& v) const
5954 return v(ref_nested());
5958 template<typename V> bool decode(size_t index, V& v)
5963 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
5964 ref_nested().clear();
5969 template<typename V> bool encode(size_t index, V& v) const
5971 if(index != type) {return false;} return v(ref_nested());
5978 struct Value_t : asn::typefield<false>
5980 ~Value_t() {clear();}
5981 size_t get_index() const {return type;}
5982 E_RABs_Admitted_ToBeAdded_Item& select_id_E_RABs_Admitted_ToBeAdded_Item() { return set<E_RABs_Admitted_ToBeAdded_Item>(1); }
5983 E_RABs_Admitted_ToBeAdded_Item const* get_id_E_RABs_Admitted_ToBeAdded_Item() const { return get<E_RABs_Admitted_ToBeAdded_Item>(1); }
5988 case 1: var.destroy<E_RABs_Admitted_ToBeAdded_Item>(); break;
5990 type = 0; ref_nested().clear();
5992 template<typename V> static inline void enumerate(V& v)
5994 v.template operator()<E_RABs_Admitted_ToBeAdded_Item>(1);
5998 template<typename V> bool decode(size_t index, V& v)
6003 case 1: v(select_id_E_RABs_Admitted_ToBeAdded_Item()); return true;
6008 template<typename V> bool encode(size_t index, V& v) const
6010 if(index != type) return false;
6013 case 1: v(var.as<E_RABs_Admitted_ToBeAdded_Item>()); return true;
6019 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
6020 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
6023 char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_Item)];
6026 asn::variant<sizeof(union_type)> var;
6030 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
6032 size_t get_index() const {return type;}
6033 void clear() {type = 0;}
6034 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(mandatory); type=1;}
6035 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
6036 template<typename V> bool decode(V& v)
6039 if(!v(ref_nested())) return false;
6040 if(equal(mandatory)) { type = 1; return true; }
6044 template<typename V> bool encode(V& v) const
6046 return v(ref_nested());
6050 template<typename V> bool decode(size_t index, V& v)
6055 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
6056 ref_nested().clear();
6061 template<typename V> bool encode(size_t index, V& v) const
6063 if(index != type) {return false;} return v(ref_nested());
6073 E-RABs-Admitted-ToBeAdded-List ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ItemIEs} }
6076 struct E_RABs_Admitted_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>
6078 static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_List_elm";}
6079 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>;
6082 struct E_RABs_Admitted_ToBeAdded_List : asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>
6084 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-List";}
6085 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>;
6086 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
6090 E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6095 struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs
6097 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6099 size_t get_index() const {return type;}
6100 bool is_unknown() const { return type == 1; }
6101 void clear() {type = 0;}
6102 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6103 template<typename V> bool decode(V& v)
6106 if(!v(ref_nested())) return false;
6107 { type = 1; return true;}
6111 template<typename V> bool encode(V& v) const
6113 return v(ref_nested());
6117 template<typename V> bool decode(size_t index, V& v)
6122 case 1: type = 1; return v(ref_nested());
6123 ref_nested().clear();
6128 template<typename V> bool encode(size_t index, V& v) const
6130 if(index != type) {return false;} return v(ref_nested());
6137 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6139 size_t get_index() const {return type;}
6140 bool is_unknown() const { return type == 1; }
6141 void clear() {type = 0;}
6142 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6143 template<typename V> bool decode(V& v)
6146 if(!v(ref_nested())) return false;
6147 { type = 1; return true;}
6151 template<typename V> bool encode(V& v) const
6153 return v(ref_nested());
6157 template<typename V> bool decode(size_t index, V& v)
6162 case 1: type = 1; return v(ref_nested());
6163 ref_nested().clear();
6168 template<typename V> bool encode(size_t index, V& v) const
6170 if(index != type) {return false;} return v(ref_nested());
6177 struct Extension_t : asn::typefield<true>
6179 ~Extension_t() {clear();}
6180 size_t get_index() const {return type;}
6181 bool is_unknown() const { return type == 1; }
6184 type = 0; ref_nested().clear();
6186 template<typename V> static inline void enumerate(V& v)
6191 template<typename V> bool decode(size_t index, V& v)
6196 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6201 template<typename V> bool encode(size_t index, V& v) const
6203 if(index != type) return false;
6211 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6213 size_t get_index() const {return type;}
6214 bool is_unknown() const { return type == 1; }
6215 void clear() {type = 0;}
6216 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6217 template<typename V> bool decode(V& v)
6220 if(!v(ref_nested())) return false;
6221 { type = 1; return true;}
6225 template<typename V> bool encode(V& v) const
6227 return v(ref_nested());
6231 template<typename V> bool decode(size_t index, V& v)
6236 case 1: type = 1; return v(ref_nested());
6237 ref_nested().clear();
6242 template<typename V> bool encode(size_t index, V& v) const
6244 if(index != type) {return false;} return v(ref_nested());
6254 E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer ::= SEQUENCE {
6256 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint,
6257 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
6258 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
6259 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs} } OPTIONAL,
6264 struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer : asn::sequence<5, 0, true, 3>
6266 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer";}
6267 using parent_t = asn::sequence<5, 0, true, 3>;
6268 struct e_RAB_ID_t : E_RAB_ID
6270 static constexpr const char* name() {return "e_RAB_ID_t";}
6271 using parent_t = E_RAB_ID;
6274 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
6275 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
6276 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6278 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
6279 using parent_t = GTPtunnelEndpoint;
6282 s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
6283 s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
6284 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6286 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
6287 using parent_t = GTPtunnelEndpoint;
6288 static constexpr bool optional = true;
6291 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
6292 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
6293 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6295 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
6296 using parent_t = GTPtunnelEndpoint;
6297 static constexpr bool optional = true;
6300 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
6301 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
6302 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>
6304 static constexpr const char* name() {return "iE_Extensions_t";}
6305 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>;
6306 static constexpr bool optional = true;
6309 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6310 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6311 template<typename V> void decode(V& v)
6314 v(s1_DL_GTPtunnelEndpoint);
6315 v(dL_Forwarding_GTPtunnelEndpoint);
6316 v(uL_Forwarding_GTPtunnelEndpoint);
6320 template<typename V> void encode(V& v) const
6323 v(s1_DL_GTPtunnelEndpoint);
6324 v(dL_Forwarding_GTPtunnelEndpoint);
6325 v(uL_Forwarding_GTPtunnelEndpoint);
6332 s1_DL_GTPtunnelEndpoint.clear();
6333 dL_Forwarding_GTPtunnelEndpoint.clear();
6334 uL_Forwarding_GTPtunnelEndpoint.clear();
6335 iE_Extensions.clear();
6339 e_RAB_ID_t e_RAB_ID;
6340 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
6341 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
6342 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
6343 iE_Extensions_t iE_Extensions;
6347 E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6352 struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs
6354 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6356 size_t get_index() const {return type;}
6357 bool is_unknown() const { return type == 1; }
6358 void clear() {type = 0;}
6359 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6360 template<typename V> bool decode(V& v)
6363 if(!v(ref_nested())) return false;
6364 { type = 1; return true;}
6368 template<typename V> bool encode(V& v) const
6370 return v(ref_nested());
6374 template<typename V> bool decode(size_t index, V& v)
6379 case 1: type = 1; return v(ref_nested());
6380 ref_nested().clear();
6385 template<typename V> bool encode(size_t index, V& v) const
6387 if(index != type) {return false;} return v(ref_nested());
6394 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6396 size_t get_index() const {return type;}
6397 bool is_unknown() const { return type == 1; }
6398 void clear() {type = 0;}
6399 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6400 template<typename V> bool decode(V& v)
6403 if(!v(ref_nested())) return false;
6404 { type = 1; return true;}
6408 template<typename V> bool encode(V& v) const
6410 return v(ref_nested());
6414 template<typename V> bool decode(size_t index, V& v)
6419 case 1: type = 1; return v(ref_nested());
6420 ref_nested().clear();
6425 template<typename V> bool encode(size_t index, V& v) const
6427 if(index != type) {return false;} return v(ref_nested());
6434 struct Extension_t : asn::typefield<true>
6436 ~Extension_t() {clear();}
6437 size_t get_index() const {return type;}
6438 bool is_unknown() const { return type == 1; }
6441 type = 0; ref_nested().clear();
6443 template<typename V> static inline void enumerate(V& v)
6448 template<typename V> bool decode(size_t index, V& v)
6453 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6458 template<typename V> bool encode(size_t index, V& v) const
6460 if(index != type) return false;
6468 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6470 size_t get_index() const {return type;}
6471 bool is_unknown() const { return type == 1; }
6472 void clear() {type = 0;}
6473 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6474 template<typename V> bool decode(V& v)
6477 if(!v(ref_nested())) return false;
6478 { type = 1; return true;}
6482 template<typename V> bool encode(V& v) const
6484 return v(ref_nested());
6488 template<typename V> bool decode(size_t index, V& v)
6493 case 1: type = 1; return v(ref_nested());
6494 ref_nested().clear();
6499 template<typename V> bool encode(size_t index, V& v) const
6501 if(index != type) {return false;} return v(ref_nested());
6511 E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer ::= SEQUENCE {
6513 seNB-GTPtunnelEndpoint GTPtunnelEndpoint,
6514 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
6519 struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 1>
6521 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer";}
6522 using parent_t = asn::sequence<3, 0, true, 1>;
6523 struct e_RAB_ID_t : E_RAB_ID
6525 static constexpr const char* name() {return "e_RAB_ID_t";}
6526 using parent_t = E_RAB_ID;
6529 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
6530 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
6531 struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6533 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
6534 using parent_t = GTPtunnelEndpoint;
6537 seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
6538 seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
6539 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>
6541 static constexpr const char* name() {return "iE_Extensions_t";}
6542 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>;
6543 static constexpr bool optional = true;
6546 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6547 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6548 template<typename V> void decode(V& v)
6551 v(seNB_GTPtunnelEndpoint);
6555 template<typename V> void encode(V& v) const
6558 v(seNB_GTPtunnelEndpoint);
6565 seNB_GTPtunnelEndpoint.clear();
6566 iE_Extensions.clear();
6570 e_RAB_ID_t e_RAB_ID;
6571 seNB_GTPtunnelEndpoint_t seNB_GTPtunnelEndpoint;
6572 iE_Extensions_t iE_Extensions;
6576 E-RABs-Admitted-ToBeAdded-ModAckItem ::= CHOICE {
6577 sCG-Bearer E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer,
6578 split-Bearer E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer,
6583 struct E_RABs_Admitted_ToBeAdded_ModAckItem : asn::choice<2, 0, true>
6585 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem";}
6586 using parent_t = asn::choice<2, 0, true>;
6587 index_type get_index() const {return index;}
6588 bool is_unknown() const {return index == 3;}
6589 void set_unknown() { set_index(3); }
6590 ~E_RABs_Admitted_ToBeAdded_ModAckItem() {clear();}
6591 struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer
6593 static constexpr const char* name() {return "sCG_Bearer_t";}
6594 using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer;
6597 struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer
6599 static constexpr const char* name() {return "split_Bearer_t";}
6600 using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer;
6607 case 1: var.destroy<sCG_Bearer_t>(); break;
6608 case 2: var.destroy<split_Bearer_t>(); break;
6613 template<typename V> bool decode(size_t idx, V& v)
6618 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
6619 case 2: set_index(2); return v(var.build<split_Bearer_t>());
6624 template<typename V> bool encode(V& v) const
6628 case 1: return v(var.as<sCG_Bearer_t>());
6629 case 2: return v(var.as<split_Bearer_t>());
6633 template<typename V> static inline void enumerate(V& v)
6635 v.template operator()<sCG_Bearer_t>(1);
6636 v.template operator()<split_Bearer_t>(2);
6639 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
6640 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
6641 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
6642 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
6644 void set_index(index_type i) {index = i; base::set();}
6647 char dummy1[sizeof(sCG_Bearer_t)];
6648 char dummy2[sizeof(split_Bearer_t)];
6651 asn::variant<sizeof(union_type)> var;
6652 index_type index {0};
6655 E-RABs-Admitted-ToBeAdded-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
6656 { ID id-E-RABs-Admitted-ToBeAdded-ModAckItem CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-ModAckItem PRESENCE mandatory}
6660 struct E_RABs_Admitted_ToBeAdded_ModAckItemIEs
6662 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
6664 size_t get_index() const {return type;}
6665 void clear() {type = 0;}
6666 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(id_E_RABs_Admitted_ToBeAdded_ModAckItem); type=1;}
6667 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
6668 template<typename V> bool decode(V& v)
6671 if(!v(ref_nested())) return false;
6672 if(equal(id_E_RABs_Admitted_ToBeAdded_ModAckItem)) { type = 1; return true; }
6676 template<typename V> bool encode(V& v) const
6678 return v(ref_nested());
6682 template<typename V> bool decode(size_t index, V& v)
6687 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_ModAckItem);} return false;
6688 ref_nested().clear();
6693 template<typename V> bool encode(size_t index, V& v) const
6695 if(index != type) {return false;} return v(ref_nested());
6702 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
6704 size_t get_index() const {return type;}
6705 void clear() {type = 0;}
6706 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(ignore); type=1;}
6707 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
6708 template<typename V> bool decode(V& v)
6711 if(!v(ref_nested())) return false;
6712 if(equal(ignore)) { type = 1; return true; }
6716 template<typename V> bool encode(V& v) const
6718 return v(ref_nested());
6722 template<typename V> bool decode(size_t index, V& v)
6727 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
6728 ref_nested().clear();
6733 template<typename V> bool encode(size_t index, V& v) const
6735 if(index != type) {return false;} return v(ref_nested());
6742 struct Value_t : asn::typefield<false>
6744 ~Value_t() {clear();}
6745 size_t get_index() const {return type;}
6746 E_RABs_Admitted_ToBeAdded_ModAckItem& select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { return set<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
6747 E_RABs_Admitted_ToBeAdded_ModAckItem const* get_id_E_RABs_Admitted_ToBeAdded_ModAckItem() const { return get<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
6752 case 1: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckItem>(); break;
6754 type = 0; ref_nested().clear();
6756 template<typename V> static inline void enumerate(V& v)
6758 v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckItem>(1);
6762 template<typename V> bool decode(size_t index, V& v)
6767 case 1: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckItem()); return true;
6772 template<typename V> bool encode(size_t index, V& v) const
6774 if(index != type) return false;
6777 case 1: v(var.as<E_RABs_Admitted_ToBeAdded_ModAckItem>()); return true;
6783 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
6784 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
6787 char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_ModAckItem)];
6790 asn::variant<sizeof(union_type)> var;
6794 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
6796 size_t get_index() const {return type;}
6797 void clear() {type = 0;}
6798 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(mandatory); type=1;}
6799 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
6800 template<typename V> bool decode(V& v)
6803 if(!v(ref_nested())) return false;
6804 if(equal(mandatory)) { type = 1; return true; }
6808 template<typename V> bool encode(V& v) const
6810 return v(ref_nested());
6814 template<typename V> bool decode(size_t index, V& v)
6819 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
6820 ref_nested().clear();
6825 template<typename V> bool encode(size_t index, V& v) const
6827 if(index != type) {return false;} return v(ref_nested());
6837 E-RABs-Admitted-ToBeAdded-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ModAckItemIEs} }
6840 struct E_RABs_Admitted_ToBeAdded_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>
6842 static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_ModAckList_elm";}
6843 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>;
6846 struct E_RABs_Admitted_ToBeAdded_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>
6848 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckList";}
6849 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>;
6850 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
6854 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6855 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
6856 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional},
6861 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs
6863 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6865 size_t get_index() const {return type;}
6866 bool is_unknown() const { return type == 3; }
6867 void clear() {type = 0;}
6868 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
6869 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
6870 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6871 template<typename V> bool decode(V& v)
6874 if(!v(ref_nested())) return false;
6875 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
6876 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
6877 else { type = 3; return true;}
6881 template<typename V> bool encode(V& v) const
6883 return v(ref_nested());
6887 template<typename V> bool decode(size_t index, V& v)
6892 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
6893 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
6894 case 3: type = 3; return v(ref_nested());
6895 ref_nested().clear();
6900 template<typename V> bool encode(size_t index, V& v) const
6902 if(index != type) {return false;} return v(ref_nested());
6909 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6911 size_t get_index() const {return type;}
6912 bool is_unknown() const { return type == 3; }
6913 void clear() {type = 0;}
6914 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
6915 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
6916 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6917 template<typename V> bool decode(V& v)
6920 if(!v(ref_nested())) return false;
6921 if(equal(ignore)) { type = 1; return true; }
6922 else if(equal(ignore)) { type = 2; return true; }
6923 else { type = 3; return true;}
6927 template<typename V> bool encode(V& v) const
6929 return v(ref_nested());
6933 template<typename V> bool decode(size_t index, V& v)
6938 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
6939 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
6940 case 3: type = 3; return v(ref_nested());
6941 ref_nested().clear();
6946 template<typename V> bool encode(size_t index, V& v) const
6948 if(index != type) {return false;} return v(ref_nested());
6955 struct Extension_t : asn::typefield<true>
6957 ~Extension_t() {clear();}
6958 size_t get_index() const {return type;}
6959 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
6960 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
6961 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
6962 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
6963 bool is_unknown() const { return type == 3; }
6968 case 1: var.destroy<PDCPSnLength>(); break;
6969 case 2: var.destroy<PDCPSnLength>(); break;
6971 type = 0; ref_nested().clear();
6973 template<typename V> static inline void enumerate(V& v)
6975 v.template operator()<PDCPSnLength>(1);
6976 v.template operator()<PDCPSnLength>(2);
6980 template<typename V> bool decode(size_t index, V& v)
6985 case 1: v(select_id_uLpDCPSnLength()); return true;
6986 case 2: v(select_id_dLPDCPSnLength()); return true;
6987 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
6992 template<typename V> bool encode(size_t index, V& v) const
6994 if(index != type) return false;
6997 case 1: v(var.as<PDCPSnLength>()); return true;
6998 case 2: v(var.as<PDCPSnLength>()); return true;
7004 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7005 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7008 char dummy1[sizeof(PDCPSnLength)];
7011 asn::variant<sizeof(union_type)> var;
7015 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7017 size_t get_index() const {return type;}
7018 bool is_unknown() const { return type == 3; }
7019 void clear() {type = 0;}
7020 void select_id_uLpDCPSnLength() { set(optional); type=1;}
7021 void select_id_dLPDCPSnLength() { set(optional); type=2;}
7022 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7023 template<typename V> bool decode(V& v)
7026 if(!v(ref_nested())) return false;
7027 if(equal(optional)) { type = 1; return true; }
7028 else if(equal(optional)) { type = 2; return true; }
7029 else { type = 3; return true;}
7033 template<typename V> bool encode(V& v) const
7035 return v(ref_nested());
7039 template<typename V> bool decode(size_t index, V& v)
7044 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
7045 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
7046 case 3: type = 3; return v(ref_nested());
7047 ref_nested().clear();
7052 template<typename V> bool encode(size_t index, V& v) const
7054 if(index != type) {return false;} return v(ref_nested());
7064 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent ::= SEQUENCE {
7065 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint,
7066 sgNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
7067 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
7068 rlc-Mode RLCMode OPTIONAL,
7069 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
7070 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
7071 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
7072 mCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
7073 -- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
7074 uL-Configuration ULConfiguration OPTIONAL,
7075 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
7076 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
7081 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
7083 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent";}
7084 using parent_t = asn::sequence<8, 0, true, 7>;
7085 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7087 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
7088 using parent_t = GTPtunnelEndpoint;
7091 s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
7092 s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
7093 struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
7095 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
7096 using parent_t = GTPtunnelEndpoint;
7097 static constexpr bool optional = true;
7100 sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
7101 sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
7102 struct rlc_Mode_t : RLCMode
7104 static constexpr const char* name() {return "rlc_Mode_t";}
7105 using parent_t = RLCMode;
7106 static constexpr bool optional = true;
7109 rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
7110 rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
7111 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7113 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
7114 using parent_t = GTPtunnelEndpoint;
7115 static constexpr bool optional = true;
7118 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
7119 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
7120 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7122 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
7123 using parent_t = GTPtunnelEndpoint;
7124 static constexpr bool optional = true;
7127 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
7128 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
7129 struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
7131 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
7132 using parent_t = E_RAB_Level_QoS_Parameters;
7133 static constexpr bool optional = true;
7136 mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
7137 mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
7138 struct uL_Configuration_t : ULConfiguration
7140 static constexpr const char* name() {return "uL_Configuration_t";}
7141 using parent_t = ULConfiguration;
7142 static constexpr bool optional = true;
7145 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
7146 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
7147 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>
7149 static constexpr const char* name() {return "iE_Extensions_t";}
7150 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>;
7151 static constexpr bool optional = true;
7154 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7155 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7156 template<typename V> void decode(V& v)
7158 v(s1_DL_GTPtunnelEndpoint);
7159 v(sgNB_UL_GTP_TEIDatPDCP);
7161 v(dL_Forwarding_GTPtunnelEndpoint);
7162 v(uL_Forwarding_GTPtunnelEndpoint);
7163 v(mCG_E_RAB_Level_QoS_Parameters);
7164 v(uL_Configuration);
7168 template<typename V> void encode(V& v) const
7170 v(s1_DL_GTPtunnelEndpoint);
7171 v(sgNB_UL_GTP_TEIDatPDCP);
7173 v(dL_Forwarding_GTPtunnelEndpoint);
7174 v(uL_Forwarding_GTPtunnelEndpoint);
7175 v(mCG_E_RAB_Level_QoS_Parameters);
7176 v(uL_Configuration);
7182 s1_DL_GTPtunnelEndpoint.clear();
7183 sgNB_UL_GTP_TEIDatPDCP.clear();
7185 dL_Forwarding_GTPtunnelEndpoint.clear();
7186 uL_Forwarding_GTPtunnelEndpoint.clear();
7187 mCG_E_RAB_Level_QoS_Parameters.clear();
7188 uL_Configuration.clear();
7189 iE_Extensions.clear();
7193 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
7194 sgNB_UL_GTP_TEIDatPDCP_t sgNB_UL_GTP_TEIDatPDCP;
7195 rlc_Mode_t rlc_Mode;
7196 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
7197 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
7198 mCG_E_RAB_Level_QoS_Parameters_t mCG_E_RAB_Level_QoS_Parameters;
7199 uL_Configuration_t uL_Configuration;
7200 iE_Extensions_t iE_Extensions;
7204 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7205 { ID id-lCID CRITICALITY ignore EXTENSION LCID PRESENCE optional},
7210 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs
7212 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7214 size_t get_index() const {return type;}
7215 bool is_unknown() const { return type == 2; }
7216 void clear() {type = 0;}
7217 void select_id_lCID() { set(id_lCID); type=1;}
7218 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7219 template<typename V> bool decode(V& v)
7222 if(!v(ref_nested())) return false;
7223 if(equal(id_lCID)) { type = 1; return true; }
7224 else { type = 2; return true;}
7228 template<typename V> bool encode(V& v) const
7230 return v(ref_nested());
7234 template<typename V> bool decode(size_t index, V& v)
7239 case 1: type = 1; if(v(ref_nested())) { return equal(id_lCID);} return false;
7240 case 2: type = 2; return v(ref_nested());
7241 ref_nested().clear();
7246 template<typename V> bool encode(size_t index, V& v) const
7248 if(index != type) {return false;} return v(ref_nested());
7255 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7257 size_t get_index() const {return type;}
7258 bool is_unknown() const { return type == 2; }
7259 void clear() {type = 0;}
7260 void select_id_lCID() { set(ignore); type=1;}
7261 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7262 template<typename V> bool decode(V& v)
7265 if(!v(ref_nested())) return false;
7266 if(equal(ignore)) { type = 1; return true; }
7267 else { type = 2; return true;}
7271 template<typename V> bool encode(V& v) const
7273 return v(ref_nested());
7277 template<typename V> bool decode(size_t index, V& v)
7282 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
7283 case 2: type = 2; return v(ref_nested());
7284 ref_nested().clear();
7289 template<typename V> bool encode(size_t index, V& v) const
7291 if(index != type) {return false;} return v(ref_nested());
7298 struct Extension_t : asn::typefield<true>
7300 ~Extension_t() {clear();}
7301 size_t get_index() const {return type;}
7302 LCID& select_id_lCID() { return set<LCID>(1); }
7303 LCID const* get_id_lCID() const { return get<LCID>(1); }
7304 bool is_unknown() const { return type == 2; }
7309 case 1: var.destroy<LCID>(); break;
7311 type = 0; ref_nested().clear();
7313 template<typename V> static inline void enumerate(V& v)
7315 v.template operator()<LCID>(1);
7319 template<typename V> bool decode(size_t index, V& v)
7324 case 1: v(select_id_lCID()); return true;
7325 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
7330 template<typename V> bool encode(size_t index, V& v) const
7332 if(index != type) return false;
7335 case 1: v(var.as<LCID>()); return true;
7341 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7342 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7345 char dummy1[sizeof(LCID)];
7348 asn::variant<sizeof(union_type)> var;
7352 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7354 size_t get_index() const {return type;}
7355 bool is_unknown() const { return type == 2; }
7356 void clear() {type = 0;}
7357 void select_id_lCID() { set(optional); type=1;}
7358 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7359 template<typename V> bool decode(V& v)
7362 if(!v(ref_nested())) return false;
7363 if(equal(optional)) { type = 1; return true; }
7364 else { type = 2; return true;}
7368 template<typename V> bool encode(V& v) const
7370 return v(ref_nested());
7374 template<typename V> bool decode(size_t index, V& v)
7379 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
7380 case 2: type = 2; return v(ref_nested());
7381 ref_nested().clear();
7386 template<typename V> bool encode(size_t index, V& v) const
7388 if(index != type) {return false;} return v(ref_nested());
7398 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
7399 sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint,
7400 secondary-sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint OPTIONAL,
7401 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
7406 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
7408 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent";}
7409 using parent_t = asn::sequence<3, 0, true, 2>;
7410 struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
7412 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
7413 using parent_t = GTPtunnelEndpoint;
7416 sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
7417 sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
7418 struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
7420 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
7421 using parent_t = GTPtunnelEndpoint;
7422 static constexpr bool optional = true;
7425 secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
7426 secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
7427 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>
7429 static constexpr const char* name() {return "iE_Extensions_t";}
7430 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>;
7431 static constexpr bool optional = true;
7434 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7435 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7436 template<typename V> void decode(V& v)
7438 v(sgNB_DL_GTP_TEIDatSCG);
7439 v(secondary_sgNB_DL_GTP_TEIDatSCG);
7443 template<typename V> void encode(V& v) const
7445 v(sgNB_DL_GTP_TEIDatSCG);
7446 v(secondary_sgNB_DL_GTP_TEIDatSCG);
7452 sgNB_DL_GTP_TEIDatSCG.clear();
7453 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
7454 iE_Extensions.clear();
7458 sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
7459 secondary_sgNB_DL_GTP_TEIDatSCG_t secondary_sgNB_DL_GTP_TEIDatSCG;
7460 iE_Extensions_t iE_Extensions;
7464 E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7469 struct E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs
7471 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7473 size_t get_index() const {return type;}
7474 bool is_unknown() const { return type == 1; }
7475 void clear() {type = 0;}
7476 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7477 template<typename V> bool decode(V& v)
7480 if(!v(ref_nested())) return false;
7481 { type = 1; return true;}
7485 template<typename V> bool encode(V& v) const
7487 return v(ref_nested());
7491 template<typename V> bool decode(size_t index, V& v)
7496 case 1: type = 1; return v(ref_nested());
7497 ref_nested().clear();
7502 template<typename V> bool encode(size_t index, V& v) const
7504 if(index != type) {return false;} return v(ref_nested());
7511 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7513 size_t get_index() const {return type;}
7514 bool is_unknown() const { return type == 1; }
7515 void clear() {type = 0;}
7516 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7517 template<typename V> bool decode(V& v)
7520 if(!v(ref_nested())) return false;
7521 { type = 1; return true;}
7525 template<typename V> bool encode(V& v) const
7527 return v(ref_nested());
7531 template<typename V> bool decode(size_t index, V& v)
7536 case 1: type = 1; return v(ref_nested());
7537 ref_nested().clear();
7542 template<typename V> bool encode(size_t index, V& v) const
7544 if(index != type) {return false;} return v(ref_nested());
7551 struct Extension_t : asn::typefield<true>
7553 ~Extension_t() {clear();}
7554 size_t get_index() const {return type;}
7555 bool is_unknown() const { return type == 1; }
7558 type = 0; ref_nested().clear();
7560 template<typename V> static inline void enumerate(V& v)
7565 template<typename V> bool decode(size_t index, V& v)
7570 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7575 template<typename V> bool encode(size_t index, V& v) const
7577 if(index != type) return false;
7585 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7587 size_t get_index() const {return type;}
7588 bool is_unknown() const { return type == 1; }
7589 void clear() {type = 0;}
7590 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7591 template<typename V> bool decode(V& v)
7594 if(!v(ref_nested())) return false;
7595 { type = 1; return true;}
7599 template<typename V> bool encode(V& v) const
7601 return v(ref_nested());
7605 template<typename V> bool decode(size_t index, V& v)
7610 case 1: type = 1; return v(ref_nested());
7611 ref_nested().clear();
7616 template<typename V> bool encode(size_t index, V& v) const
7618 if(index != type) {return false;} return v(ref_nested());
7628 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item ::= SEQUENCE {
7630 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
7631 resource-configuration CHOICE {
7632 sgNBPDCPpresent E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent,
7633 sgNBPDCPnotpresent E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent,
7636 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs} } OPTIONAL,
7641 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item : asn::sequence<4, 0, true, 1>
7643 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item";}
7644 using parent_t = asn::sequence<4, 0, true, 1>;
7645 struct e_RAB_ID_t : E_RAB_ID
7647 static constexpr const char* name() {return "e_RAB_ID_t";}
7648 using parent_t = E_RAB_ID;
7651 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
7652 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
7653 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
7655 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
7656 using parent_t = EN_DC_ResourceConfiguration;
7659 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
7660 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
7661 struct resource_configuration_t : asn::choice<2, 0, true>
7663 static constexpr const char* name() {return "resource_configuration_t";}
7664 using parent_t = asn::choice<2, 0, true>;
7665 index_type get_index() const {return index;}
7666 bool is_unknown() const {return index == 3;}
7667 void set_unknown() { set_index(3); }
7668 ~resource_configuration_t() {clear();}
7669 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent
7671 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
7672 using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent;
7675 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent
7677 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
7678 using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent;
7685 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
7686 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
7691 template<typename V> bool decode(size_t idx, V& v)
7696 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
7697 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
7702 template<typename V> bool encode(V& v) const
7706 case 1: return v(var.as<sgNBPDCPpresent_t>());
7707 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
7711 template<typename V> static inline void enumerate(V& v)
7713 v.template operator()<sgNBPDCPpresent_t>(1);
7714 v.template operator()<sgNBPDCPnotpresent_t>(2);
7717 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
7718 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
7719 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
7720 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
7722 void set_index(index_type i) {index = i; base::set();}
7725 char dummy1[sizeof(sgNBPDCPpresent_t)];
7726 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
7729 asn::variant<sizeof(union_type)> var;
7730 index_type index {0};
7732 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
7733 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
7734 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>
7736 static constexpr const char* name() {return "iE_Extensions_t";}
7737 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>;
7738 static constexpr bool optional = true;
7741 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7742 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7743 template<typename V> void decode(V& v)
7746 v(en_DC_ResourceConfiguration);
7747 v(resource_configuration);
7751 template<typename V> void encode(V& v) const
7754 v(en_DC_ResourceConfiguration);
7755 v(resource_configuration);
7762 en_DC_ResourceConfiguration.clear();
7763 resource_configuration.clear();
7764 iE_Extensions.clear();
7768 e_RAB_ID_t e_RAB_ID;
7769 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
7770 resource_configuration_t resource_configuration;
7771 iE_Extensions_t iE_Extensions;
7775 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
7776 { ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item PRESENCE mandatory}
7780 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs
7782 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
7784 size_t get_index() const {return type;}
7785 void clear() {type = 0;}
7786 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item); type=1;}
7787 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
7788 template<typename V> bool decode(V& v)
7791 if(!v(ref_nested())) return false;
7792 if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)) { type = 1; return true; }
7796 template<typename V> bool encode(V& v) const
7798 return v(ref_nested());
7802 template<typename V> bool decode(size_t index, V& v)
7807 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item);} return false;
7808 ref_nested().clear();
7813 template<typename V> bool encode(size_t index, V& v) const
7815 if(index != type) {return false;} return v(ref_nested());
7822 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
7824 size_t get_index() const {return type;}
7825 void clear() {type = 0;}
7826 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(ignore); type=1;}
7827 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
7828 template<typename V> bool decode(V& v)
7831 if(!v(ref_nested())) return false;
7832 if(equal(ignore)) { type = 1; return true; }
7836 template<typename V> bool encode(V& v) const
7838 return v(ref_nested());
7842 template<typename V> bool decode(size_t index, V& v)
7847 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
7848 ref_nested().clear();
7853 template<typename V> bool encode(size_t index, V& v) const
7855 if(index != type) {return false;} return v(ref_nested());
7862 struct Value_t : asn::typefield<false>
7864 ~Value_t() {clear();}
7865 size_t get_index() const {return type;}
7866 E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
7867 E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
7872 case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(); break;
7874 type = 0; ref_nested().clear();
7876 template<typename V> static inline void enumerate(V& v)
7878 v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1);
7882 template<typename V> bool decode(size_t index, V& v)
7887 case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item()); return true;
7892 template<typename V> bool encode(size_t index, V& v) const
7894 if(index != type) return false;
7897 case 1: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>()); return true;
7903 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7904 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7907 char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)];
7910 asn::variant<sizeof(union_type)> var;
7914 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
7916 size_t get_index() const {return type;}
7917 void clear() {type = 0;}
7918 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(mandatory); type=1;}
7919 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
7920 template<typename V> bool decode(V& v)
7923 if(!v(ref_nested())) return false;
7924 if(equal(mandatory)) { type = 1; return true; }
7928 template<typename V> bool encode(V& v) const
7930 return v(ref_nested());
7934 template<typename V> bool decode(size_t index, V& v)
7939 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
7940 ref_nested().clear();
7945 template<typename V> bool encode(size_t index, V& v) const
7947 if(index != type) {return false;} return v(ref_nested());
7957 E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs} }
7960 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>
7962 static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm";}
7963 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>;
7966 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>
7968 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList";}
7969 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>;
7970 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
7974 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7975 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
7976 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional},
7981 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs
7983 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7985 size_t get_index() const {return type;}
7986 bool is_unknown() const { return type == 3; }
7987 void clear() {type = 0;}
7988 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
7989 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
7990 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7991 template<typename V> bool decode(V& v)
7994 if(!v(ref_nested())) return false;
7995 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
7996 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
7997 else { type = 3; return true;}
8001 template<typename V> bool encode(V& v) const
8003 return v(ref_nested());
8007 template<typename V> bool decode(size_t index, V& v)
8012 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
8013 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
8014 case 3: type = 3; return v(ref_nested());
8015 ref_nested().clear();
8020 template<typename V> bool encode(size_t index, V& v) const
8022 if(index != type) {return false;} return v(ref_nested());
8029 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8031 size_t get_index() const {return type;}
8032 bool is_unknown() const { return type == 3; }
8033 void clear() {type = 0;}
8034 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
8035 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
8036 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8037 template<typename V> bool decode(V& v)
8040 if(!v(ref_nested())) return false;
8041 if(equal(ignore)) { type = 1; return true; }
8042 else if(equal(ignore)) { type = 2; return true; }
8043 else { type = 3; return true;}
8047 template<typename V> bool encode(V& v) const
8049 return v(ref_nested());
8053 template<typename V> bool decode(size_t index, V& v)
8058 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8059 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
8060 case 3: type = 3; return v(ref_nested());
8061 ref_nested().clear();
8066 template<typename V> bool encode(size_t index, V& v) const
8068 if(index != type) {return false;} return v(ref_nested());
8075 struct Extension_t : asn::typefield<true>
8077 ~Extension_t() {clear();}
8078 size_t get_index() const {return type;}
8079 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
8080 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
8081 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
8082 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
8083 bool is_unknown() const { return type == 3; }
8088 case 1: var.destroy<PDCPSnLength>(); break;
8089 case 2: var.destroy<PDCPSnLength>(); break;
8091 type = 0; ref_nested().clear();
8093 template<typename V> static inline void enumerate(V& v)
8095 v.template operator()<PDCPSnLength>(1);
8096 v.template operator()<PDCPSnLength>(2);
8100 template<typename V> bool decode(size_t index, V& v)
8105 case 1: v(select_id_uLpDCPSnLength()); return true;
8106 case 2: v(select_id_dLPDCPSnLength()); return true;
8107 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
8112 template<typename V> bool encode(size_t index, V& v) const
8114 if(index != type) return false;
8117 case 1: v(var.as<PDCPSnLength>()); return true;
8118 case 2: v(var.as<PDCPSnLength>()); return true;
8124 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
8125 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
8128 char dummy1[sizeof(PDCPSnLength)];
8131 asn::variant<sizeof(union_type)> var;
8135 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8137 size_t get_index() const {return type;}
8138 bool is_unknown() const { return type == 3; }
8139 void clear() {type = 0;}
8140 void select_id_uLpDCPSnLength() { set(optional); type=1;}
8141 void select_id_dLPDCPSnLength() { set(optional); type=2;}
8142 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8143 template<typename V> bool decode(V& v)
8146 if(!v(ref_nested())) return false;
8147 if(equal(optional)) { type = 1; return true; }
8148 else if(equal(optional)) { type = 2; return true; }
8149 else { type = 3; return true;}
8153 template<typename V> bool encode(V& v) const
8155 return v(ref_nested());
8159 template<typename V> bool decode(size_t index, V& v)
8164 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
8165 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
8166 case 3: type = 3; return v(ref_nested());
8167 ref_nested().clear();
8172 template<typename V> bool encode(size_t index, V& v) const
8174 if(index != type) {return false;} return v(ref_nested());
8184 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
8185 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint,
8186 sgNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
8187 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
8188 rlc-Mode RLCMode OPTIONAL,
8189 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
8190 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
8191 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
8192 mCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
8193 -- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
8194 uL-Configuration ULConfiguration OPTIONAL,
8195 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
8196 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
8201 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
8203 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent";}
8204 using parent_t = asn::sequence<8, 0, true, 7>;
8205 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8207 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
8208 using parent_t = GTPtunnelEndpoint;
8211 s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
8212 s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
8213 struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
8215 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
8216 using parent_t = GTPtunnelEndpoint;
8217 static constexpr bool optional = true;
8220 sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
8221 sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
8222 struct rlc_Mode_t : RLCMode
8224 static constexpr const char* name() {return "rlc_Mode_t";}
8225 using parent_t = RLCMode;
8226 static constexpr bool optional = true;
8229 rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
8230 rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
8231 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8233 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
8234 using parent_t = GTPtunnelEndpoint;
8235 static constexpr bool optional = true;
8238 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
8239 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
8240 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8242 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
8243 using parent_t = GTPtunnelEndpoint;
8244 static constexpr bool optional = true;
8247 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
8248 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
8249 struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
8251 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
8252 using parent_t = E_RAB_Level_QoS_Parameters;
8253 static constexpr bool optional = true;
8256 mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
8257 mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
8258 struct uL_Configuration_t : ULConfiguration
8260 static constexpr const char* name() {return "uL_Configuration_t";}
8261 using parent_t = ULConfiguration;
8262 static constexpr bool optional = true;
8265 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
8266 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
8267 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
8269 static constexpr const char* name() {return "iE_Extensions_t";}
8270 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
8271 static constexpr bool optional = true;
8274 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8275 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8276 template<typename V> void decode(V& v)
8278 v(s1_DL_GTPtunnelEndpoint);
8279 v(sgNB_UL_GTP_TEIDatPDCP);
8281 v(dL_Forwarding_GTPtunnelEndpoint);
8282 v(uL_Forwarding_GTPtunnelEndpoint);
8283 v(mCG_E_RAB_Level_QoS_Parameters);
8284 v(uL_Configuration);
8288 template<typename V> void encode(V& v) const
8290 v(s1_DL_GTPtunnelEndpoint);
8291 v(sgNB_UL_GTP_TEIDatPDCP);
8293 v(dL_Forwarding_GTPtunnelEndpoint);
8294 v(uL_Forwarding_GTPtunnelEndpoint);
8295 v(mCG_E_RAB_Level_QoS_Parameters);
8296 v(uL_Configuration);
8302 s1_DL_GTPtunnelEndpoint.clear();
8303 sgNB_UL_GTP_TEIDatPDCP.clear();
8305 dL_Forwarding_GTPtunnelEndpoint.clear();
8306 uL_Forwarding_GTPtunnelEndpoint.clear();
8307 mCG_E_RAB_Level_QoS_Parameters.clear();
8308 uL_Configuration.clear();
8309 iE_Extensions.clear();
8313 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
8314 sgNB_UL_GTP_TEIDatPDCP_t sgNB_UL_GTP_TEIDatPDCP;
8315 rlc_Mode_t rlc_Mode;
8316 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
8317 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
8318 mCG_E_RAB_Level_QoS_Parameters_t mCG_E_RAB_Level_QoS_Parameters;
8319 uL_Configuration_t uL_Configuration;
8320 iE_Extensions_t iE_Extensions;
8324 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8325 {ID id-lCID CRITICALITY ignore EXTENSION LCID PRESENCE optional},
8330 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
8332 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8334 size_t get_index() const {return type;}
8335 bool is_unknown() const { return type == 2; }
8336 void clear() {type = 0;}
8337 void select_id_lCID() { set(id_lCID); type=1;}
8338 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8339 template<typename V> bool decode(V& v)
8342 if(!v(ref_nested())) return false;
8343 if(equal(id_lCID)) { type = 1; return true; }
8344 else { type = 2; return true;}
8348 template<typename V> bool encode(V& v) const
8350 return v(ref_nested());
8354 template<typename V> bool decode(size_t index, V& v)
8359 case 1: type = 1; if(v(ref_nested())) { return equal(id_lCID);} return false;
8360 case 2: type = 2; return v(ref_nested());
8361 ref_nested().clear();
8366 template<typename V> bool encode(size_t index, V& v) const
8368 if(index != type) {return false;} return v(ref_nested());
8375 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8377 size_t get_index() const {return type;}
8378 bool is_unknown() const { return type == 2; }
8379 void clear() {type = 0;}
8380 void select_id_lCID() { set(ignore); type=1;}
8381 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8382 template<typename V> bool decode(V& v)
8385 if(!v(ref_nested())) return false;
8386 if(equal(ignore)) { type = 1; return true; }
8387 else { type = 2; return true;}
8391 template<typename V> bool encode(V& v) const
8393 return v(ref_nested());
8397 template<typename V> bool decode(size_t index, V& v)
8402 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8403 case 2: type = 2; return v(ref_nested());
8404 ref_nested().clear();
8409 template<typename V> bool encode(size_t index, V& v) const
8411 if(index != type) {return false;} return v(ref_nested());
8418 struct Extension_t : asn::typefield<true>
8420 ~Extension_t() {clear();}
8421 size_t get_index() const {return type;}
8422 LCID& select_id_lCID() { return set<LCID>(1); }
8423 LCID const* get_id_lCID() const { return get<LCID>(1); }
8424 bool is_unknown() const { return type == 2; }
8429 case 1: var.destroy<LCID>(); break;
8431 type = 0; ref_nested().clear();
8433 template<typename V> static inline void enumerate(V& v)
8435 v.template operator()<LCID>(1);
8439 template<typename V> bool decode(size_t index, V& v)
8444 case 1: v(select_id_lCID()); return true;
8445 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
8450 template<typename V> bool encode(size_t index, V& v) const
8452 if(index != type) return false;
8455 case 1: v(var.as<LCID>()); return true;
8461 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
8462 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
8465 char dummy1[sizeof(LCID)];
8468 asn::variant<sizeof(union_type)> var;
8472 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8474 size_t get_index() const {return type;}
8475 bool is_unknown() const { return type == 2; }
8476 void clear() {type = 0;}
8477 void select_id_lCID() { set(optional); type=1;}
8478 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8479 template<typename V> bool decode(V& v)
8482 if(!v(ref_nested())) return false;
8483 if(equal(optional)) { type = 1; return true; }
8484 else { type = 2; return true;}
8488 template<typename V> bool encode(V& v) const
8490 return v(ref_nested());
8494 template<typename V> bool decode(size_t index, V& v)
8499 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
8500 case 2: type = 2; return v(ref_nested());
8501 ref_nested().clear();
8506 template<typename V> bool encode(size_t index, V& v) const
8508 if(index != type) {return false;} return v(ref_nested());
8518 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
8519 sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint,
8520 secondary-sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint OPTIONAL,
8521 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
8526 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
8528 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent";}
8529 using parent_t = asn::sequence<3, 0, true, 2>;
8530 struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
8532 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
8533 using parent_t = GTPtunnelEndpoint;
8536 sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
8537 sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
8538 struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
8540 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
8541 using parent_t = GTPtunnelEndpoint;
8542 static constexpr bool optional = true;
8545 secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
8546 secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
8547 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
8549 static constexpr const char* name() {return "iE_Extensions_t";}
8550 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
8551 static constexpr bool optional = true;
8554 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8555 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8556 template<typename V> void decode(V& v)
8558 v(sgNB_DL_GTP_TEIDatSCG);
8559 v(secondary_sgNB_DL_GTP_TEIDatSCG);
8563 template<typename V> void encode(V& v) const
8565 v(sgNB_DL_GTP_TEIDatSCG);
8566 v(secondary_sgNB_DL_GTP_TEIDatSCG);
8572 sgNB_DL_GTP_TEIDatSCG.clear();
8573 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
8574 iE_Extensions.clear();
8578 sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
8579 secondary_sgNB_DL_GTP_TEIDatSCG_t secondary_sgNB_DL_GTP_TEIDatSCG;
8580 iE_Extensions_t iE_Extensions;
8584 E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8589 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs
8591 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8593 size_t get_index() const {return type;}
8594 bool is_unknown() const { return type == 1; }
8595 void clear() {type = 0;}
8596 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8597 template<typename V> bool decode(V& v)
8600 if(!v(ref_nested())) return false;
8601 { type = 1; return true;}
8605 template<typename V> bool encode(V& v) const
8607 return v(ref_nested());
8611 template<typename V> bool decode(size_t index, V& v)
8616 case 1: type = 1; return v(ref_nested());
8617 ref_nested().clear();
8622 template<typename V> bool encode(size_t index, V& v) const
8624 if(index != type) {return false;} return v(ref_nested());
8631 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8633 size_t get_index() const {return type;}
8634 bool is_unknown() const { return type == 1; }
8635 void clear() {type = 0;}
8636 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8637 template<typename V> bool decode(V& v)
8640 if(!v(ref_nested())) return false;
8641 { type = 1; return true;}
8645 template<typename V> bool encode(V& v) const
8647 return v(ref_nested());
8651 template<typename V> bool decode(size_t index, V& v)
8656 case 1: type = 1; return v(ref_nested());
8657 ref_nested().clear();
8662 template<typename V> bool encode(size_t index, V& v) const
8664 if(index != type) {return false;} return v(ref_nested());
8671 struct Extension_t : asn::typefield<true>
8673 ~Extension_t() {clear();}
8674 size_t get_index() const {return type;}
8675 bool is_unknown() const { return type == 1; }
8678 type = 0; ref_nested().clear();
8680 template<typename V> static inline void enumerate(V& v)
8685 template<typename V> bool decode(size_t index, V& v)
8690 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8695 template<typename V> bool encode(size_t index, V& v) const
8697 if(index != type) return false;
8705 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8707 size_t get_index() const {return type;}
8708 bool is_unknown() const { return type == 1; }
8709 void clear() {type = 0;}
8710 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8711 template<typename V> bool decode(V& v)
8714 if(!v(ref_nested())) return false;
8715 { type = 1; return true;}
8719 template<typename V> bool encode(V& v) const
8721 return v(ref_nested());
8725 template<typename V> bool decode(size_t index, V& v)
8730 case 1: type = 1; return v(ref_nested());
8731 ref_nested().clear();
8736 template<typename V> bool encode(size_t index, V& v) const
8738 if(index != type) {return false;} return v(ref_nested());
8748 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item ::= SEQUENCE {
8750 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
8751 resource-configuration CHOICE {
8752 sgNBPDCPpresent E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent,
8753 sgNBPDCPnotpresent E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent,
8756 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs} } OPTIONAL,
8761 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
8763 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item";}
8764 using parent_t = asn::sequence<4, 0, true, 1>;
8765 struct e_RAB_ID_t : E_RAB_ID
8767 static constexpr const char* name() {return "e_RAB_ID_t";}
8768 using parent_t = E_RAB_ID;
8771 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
8772 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
8773 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
8775 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
8776 using parent_t = EN_DC_ResourceConfiguration;
8779 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
8780 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
8781 struct resource_configuration_t : asn::choice<2, 0, true>
8783 static constexpr const char* name() {return "resource_configuration_t";}
8784 using parent_t = asn::choice<2, 0, true>;
8785 index_type get_index() const {return index;}
8786 bool is_unknown() const {return index == 3;}
8787 void set_unknown() { set_index(3); }
8788 ~resource_configuration_t() {clear();}
8789 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent
8791 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
8792 using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent;
8795 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent
8797 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
8798 using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent;
8805 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
8806 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
8811 template<typename V> bool decode(size_t idx, V& v)
8816 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
8817 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
8822 template<typename V> bool encode(V& v) const
8826 case 1: return v(var.as<sgNBPDCPpresent_t>());
8827 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
8831 template<typename V> static inline void enumerate(V& v)
8833 v.template operator()<sgNBPDCPpresent_t>(1);
8834 v.template operator()<sgNBPDCPnotpresent_t>(2);
8837 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
8838 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
8839 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
8840 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
8842 void set_index(index_type i) {index = i; base::set();}
8845 char dummy1[sizeof(sgNBPDCPpresent_t)];
8846 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
8849 asn::variant<sizeof(union_type)> var;
8850 index_type index {0};
8852 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
8853 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
8854 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>
8856 static constexpr const char* name() {return "iE_Extensions_t";}
8857 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>;
8858 static constexpr bool optional = true;
8861 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8862 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8863 template<typename V> void decode(V& v)
8866 v(en_DC_ResourceConfiguration);
8867 v(resource_configuration);
8871 template<typename V> void encode(V& v) const
8874 v(en_DC_ResourceConfiguration);
8875 v(resource_configuration);
8882 en_DC_ResourceConfiguration.clear();
8883 resource_configuration.clear();
8884 iE_Extensions.clear();
8888 e_RAB_ID_t e_RAB_ID;
8889 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
8890 resource_configuration_t resource_configuration;
8891 iE_Extensions_t iE_Extensions;
8895 E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
8896 { ID id-E-RABs-Admitted-ToBeAdded-SgNBModAck-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-SgNBModAck-Item PRESENCE mandatory}
8900 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs
8902 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
8904 size_t get_index() const {return type;}
8905 void clear() {type = 0;}
8906 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item); type=1;}
8907 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
8908 template<typename V> bool decode(V& v)
8911 if(!v(ref_nested())) return false;
8912 if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item)) { type = 1; return true; }
8916 template<typename V> bool encode(V& v) const
8918 return v(ref_nested());
8922 template<typename V> bool decode(size_t index, V& v)
8927 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item);} return false;
8928 ref_nested().clear();
8933 template<typename V> bool encode(size_t index, V& v) const
8935 if(index != type) {return false;} return v(ref_nested());
8942 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
8944 size_t get_index() const {return type;}
8945 void clear() {type = 0;}
8946 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(ignore); type=1;}
8947 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
8948 template<typename V> bool decode(V& v)
8951 if(!v(ref_nested())) return false;
8952 if(equal(ignore)) { type = 1; return true; }
8956 template<typename V> bool encode(V& v) const
8958 return v(ref_nested());
8962 template<typename V> bool decode(size_t index, V& v)
8967 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8968 ref_nested().clear();
8973 template<typename V> bool encode(size_t index, V& v) const
8975 if(index != type) {return false;} return v(ref_nested());
8982 struct Value_t : asn::typefield<false>
8984 ~Value_t() {clear();}
8985 size_t get_index() const {return type;}
8986 E_RABs_Admitted_ToBeAdded_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
8987 E_RABs_Admitted_ToBeAdded_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
8992 case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(); break;
8994 type = 0; ref_nested().clear();
8996 template<typename V> static inline void enumerate(V& v)
8998 v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1);
9002 template<typename V> bool decode(size_t index, V& v)
9007 case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item()); return true;
9012 template<typename V> bool encode(size_t index, V& v) const
9014 if(index != type) return false;
9017 case 1: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>()); return true;
9023 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9024 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9027 char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_SgNBModAck_Item)];
9030 asn::variant<sizeof(union_type)> var;
9034 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
9036 size_t get_index() const {return type;}
9037 void clear() {type = 0;}
9038 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(mandatory); type=1;}
9039 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
9040 template<typename V> bool decode(V& v)
9043 if(!v(ref_nested())) return false;
9044 if(equal(mandatory)) { type = 1; return true; }
9048 template<typename V> bool encode(V& v) const
9050 return v(ref_nested());
9054 template<typename V> bool decode(size_t index, V& v)
9059 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
9060 ref_nested().clear();
9065 template<typename V> bool encode(size_t index, V& v) const
9067 if(index != type) {return false;} return v(ref_nested());
9077 E-RABs-Admitted-ToBeAdded-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs} }
9080 struct E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>
9082 static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm";}
9083 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>;
9086 struct E_RABs_Admitted_ToBeAdded_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>
9088 static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAckList";}
9089 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>;
9090 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
9094 E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9099 struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs
9101 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9103 size_t get_index() const {return type;}
9104 bool is_unknown() const { return type == 1; }
9105 void clear() {type = 0;}
9106 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9107 template<typename V> bool decode(V& v)
9110 if(!v(ref_nested())) return false;
9111 { type = 1; return true;}
9115 template<typename V> bool encode(V& v) const
9117 return v(ref_nested());
9121 template<typename V> bool decode(size_t index, V& v)
9126 case 1: type = 1; return v(ref_nested());
9127 ref_nested().clear();
9132 template<typename V> bool encode(size_t index, V& v) const
9134 if(index != type) {return false;} return v(ref_nested());
9141 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9143 size_t get_index() const {return type;}
9144 bool is_unknown() const { return type == 1; }
9145 void clear() {type = 0;}
9146 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9147 template<typename V> bool decode(V& v)
9150 if(!v(ref_nested())) return false;
9151 { type = 1; return true;}
9155 template<typename V> bool encode(V& v) const
9157 return v(ref_nested());
9161 template<typename V> bool decode(size_t index, V& v)
9166 case 1: type = 1; return v(ref_nested());
9167 ref_nested().clear();
9172 template<typename V> bool encode(size_t index, V& v) const
9174 if(index != type) {return false;} return v(ref_nested());
9181 struct Extension_t : asn::typefield<true>
9183 ~Extension_t() {clear();}
9184 size_t get_index() const {return type;}
9185 bool is_unknown() const { return type == 1; }
9188 type = 0; ref_nested().clear();
9190 template<typename V> static inline void enumerate(V& v)
9195 template<typename V> bool decode(size_t index, V& v)
9200 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9205 template<typename V> bool encode(size_t index, V& v) const
9207 if(index != type) return false;
9215 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9217 size_t get_index() const {return type;}
9218 bool is_unknown() const { return type == 1; }
9219 void clear() {type = 0;}
9220 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9221 template<typename V> bool decode(V& v)
9224 if(!v(ref_nested())) return false;
9225 { type = 1; return true;}
9229 template<typename V> bool encode(V& v) const
9231 return v(ref_nested());
9235 template<typename V> bool decode(size_t index, V& v)
9240 case 1: type = 1; return v(ref_nested());
9241 ref_nested().clear();
9246 template<typename V> bool encode(size_t index, V& v) const
9248 if(index != type) {return false;} return v(ref_nested());
9258 E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer ::= SEQUENCE {
9260 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
9261 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs} } OPTIONAL,
9266 struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer : asn::sequence<3, 0, true, 2>
9268 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer";}
9269 using parent_t = asn::sequence<3, 0, true, 2>;
9270 struct e_RAB_ID_t : E_RAB_ID
9272 static constexpr const char* name() {return "e_RAB_ID_t";}
9273 using parent_t = E_RAB_ID;
9276 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
9277 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
9278 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
9280 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
9281 using parent_t = GTPtunnelEndpoint;
9282 static constexpr bool optional = true;
9285 s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
9286 s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
9287 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>
9289 static constexpr const char* name() {return "iE_Extensions_t";}
9290 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>;
9291 static constexpr bool optional = true;
9294 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9295 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9296 template<typename V> void decode(V& v)
9299 v(s1_DL_GTPtunnelEndpoint);
9303 template<typename V> void encode(V& v) const
9306 v(s1_DL_GTPtunnelEndpoint);
9313 s1_DL_GTPtunnelEndpoint.clear();
9314 iE_Extensions.clear();
9318 e_RAB_ID_t e_RAB_ID;
9319 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
9320 iE_Extensions_t iE_Extensions;
9324 E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9329 struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs
9331 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9333 size_t get_index() const {return type;}
9334 bool is_unknown() const { return type == 1; }
9335 void clear() {type = 0;}
9336 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9337 template<typename V> bool decode(V& v)
9340 if(!v(ref_nested())) return false;
9341 { type = 1; return true;}
9345 template<typename V> bool encode(V& v) const
9347 return v(ref_nested());
9351 template<typename V> bool decode(size_t index, V& v)
9356 case 1: type = 1; return v(ref_nested());
9357 ref_nested().clear();
9362 template<typename V> bool encode(size_t index, V& v) const
9364 if(index != type) {return false;} return v(ref_nested());
9371 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9373 size_t get_index() const {return type;}
9374 bool is_unknown() const { return type == 1; }
9375 void clear() {type = 0;}
9376 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9377 template<typename V> bool decode(V& v)
9380 if(!v(ref_nested())) return false;
9381 { type = 1; return true;}
9385 template<typename V> bool encode(V& v) const
9387 return v(ref_nested());
9391 template<typename V> bool decode(size_t index, V& v)
9396 case 1: type = 1; return v(ref_nested());
9397 ref_nested().clear();
9402 template<typename V> bool encode(size_t index, V& v) const
9404 if(index != type) {return false;} return v(ref_nested());
9411 struct Extension_t : asn::typefield<true>
9413 ~Extension_t() {clear();}
9414 size_t get_index() const {return type;}
9415 bool is_unknown() const { return type == 1; }
9418 type = 0; ref_nested().clear();
9420 template<typename V> static inline void enumerate(V& v)
9425 template<typename V> bool decode(size_t index, V& v)
9430 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9435 template<typename V> bool encode(size_t index, V& v) const
9437 if(index != type) return false;
9445 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9447 size_t get_index() const {return type;}
9448 bool is_unknown() const { return type == 1; }
9449 void clear() {type = 0;}
9450 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9451 template<typename V> bool decode(V& v)
9454 if(!v(ref_nested())) return false;
9455 { type = 1; return true;}
9459 template<typename V> bool encode(V& v) const
9461 return v(ref_nested());
9465 template<typename V> bool decode(size_t index, V& v)
9470 case 1: type = 1; return v(ref_nested());
9471 ref_nested().clear();
9476 template<typename V> bool encode(size_t index, V& v) const
9478 if(index != type) {return false;} return v(ref_nested());
9488 E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer ::= SEQUENCE {
9490 seNB-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
9491 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
9496 struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 2>
9498 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer";}
9499 using parent_t = asn::sequence<3, 0, true, 2>;
9500 struct e_RAB_ID_t : E_RAB_ID
9502 static constexpr const char* name() {return "e_RAB_ID_t";}
9503 using parent_t = E_RAB_ID;
9506 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
9507 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
9508 struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
9510 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
9511 using parent_t = GTPtunnelEndpoint;
9512 static constexpr bool optional = true;
9515 seNB_GTPtunnelEndpoint_t& set_seNB_GTPtunnelEndpoint() { seNB_GTPtunnelEndpoint.setpresent(true); return seNB_GTPtunnelEndpoint;}
9516 seNB_GTPtunnelEndpoint_t const* get_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint.is_valid() ? &seNB_GTPtunnelEndpoint : nullptr;}
9517 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>
9519 static constexpr const char* name() {return "iE_Extensions_t";}
9520 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>;
9521 static constexpr bool optional = true;
9524 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9525 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9526 template<typename V> void decode(V& v)
9529 v(seNB_GTPtunnelEndpoint);
9533 template<typename V> void encode(V& v) const
9536 v(seNB_GTPtunnelEndpoint);
9543 seNB_GTPtunnelEndpoint.clear();
9544 iE_Extensions.clear();
9548 e_RAB_ID_t e_RAB_ID;
9549 seNB_GTPtunnelEndpoint_t seNB_GTPtunnelEndpoint;
9550 iE_Extensions_t iE_Extensions;
9554 E-RABs-Admitted-ToBeModified-ModAckItem ::= CHOICE {
9555 sCG-Bearer E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer,
9556 split-Bearer E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer,
9561 struct E_RABs_Admitted_ToBeModified_ModAckItem : asn::choice<2, 0, true>
9563 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem";}
9564 using parent_t = asn::choice<2, 0, true>;
9565 index_type get_index() const {return index;}
9566 bool is_unknown() const {return index == 3;}
9567 void set_unknown() { set_index(3); }
9568 ~E_RABs_Admitted_ToBeModified_ModAckItem() {clear();}
9569 struct sCG_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer
9571 static constexpr const char* name() {return "sCG_Bearer_t";}
9572 using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer;
9575 struct split_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer
9577 static constexpr const char* name() {return "split_Bearer_t";}
9578 using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer;
9585 case 1: var.destroy<sCG_Bearer_t>(); break;
9586 case 2: var.destroy<split_Bearer_t>(); break;
9591 template<typename V> bool decode(size_t idx, V& v)
9596 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
9597 case 2: set_index(2); return v(var.build<split_Bearer_t>());
9602 template<typename V> bool encode(V& v) const
9606 case 1: return v(var.as<sCG_Bearer_t>());
9607 case 2: return v(var.as<split_Bearer_t>());
9611 template<typename V> static inline void enumerate(V& v)
9613 v.template operator()<sCG_Bearer_t>(1);
9614 v.template operator()<split_Bearer_t>(2);
9617 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
9618 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
9619 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
9620 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
9622 void set_index(index_type i) {index = i; base::set();}
9625 char dummy1[sizeof(sCG_Bearer_t)];
9626 char dummy2[sizeof(split_Bearer_t)];
9629 asn::variant<sizeof(union_type)> var;
9630 index_type index {0};
9633 E-RABs-Admitted-ToBeModified-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
9634 { ID id-E-RABs-Admitted-ToBeModified-ModAckItem CRITICALITY ignore TYPE E-RABs-Admitted-ToBeModified-ModAckItem PRESENCE mandatory}
9638 struct E_RABs_Admitted_ToBeModified_ModAckItemIEs
9640 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
9642 size_t get_index() const {return type;}
9643 void clear() {type = 0;}
9644 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(id_E_RABs_Admitted_ToBeModified_ModAckItem); type=1;}
9645 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
9646 template<typename V> bool decode(V& v)
9649 if(!v(ref_nested())) return false;
9650 if(equal(id_E_RABs_Admitted_ToBeModified_ModAckItem)) { type = 1; return true; }
9654 template<typename V> bool encode(V& v) const
9656 return v(ref_nested());
9660 template<typename V> bool decode(size_t index, V& v)
9665 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_ModAckItem);} return false;
9666 ref_nested().clear();
9671 template<typename V> bool encode(size_t index, V& v) const
9673 if(index != type) {return false;} return v(ref_nested());
9680 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
9682 size_t get_index() const {return type;}
9683 void clear() {type = 0;}
9684 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(ignore); type=1;}
9685 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
9686 template<typename V> bool decode(V& v)
9689 if(!v(ref_nested())) return false;
9690 if(equal(ignore)) { type = 1; return true; }
9694 template<typename V> bool encode(V& v) const
9696 return v(ref_nested());
9700 template<typename V> bool decode(size_t index, V& v)
9705 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
9706 ref_nested().clear();
9711 template<typename V> bool encode(size_t index, V& v) const
9713 if(index != type) {return false;} return v(ref_nested());
9720 struct Value_t : asn::typefield<false>
9722 ~Value_t() {clear();}
9723 size_t get_index() const {return type;}
9724 E_RABs_Admitted_ToBeModified_ModAckItem& select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { return set<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
9725 E_RABs_Admitted_ToBeModified_ModAckItem const* get_id_E_RABs_Admitted_ToBeModified_ModAckItem() const { return get<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
9730 case 1: var.destroy<E_RABs_Admitted_ToBeModified_ModAckItem>(); break;
9732 type = 0; ref_nested().clear();
9734 template<typename V> static inline void enumerate(V& v)
9736 v.template operator()<E_RABs_Admitted_ToBeModified_ModAckItem>(1);
9740 template<typename V> bool decode(size_t index, V& v)
9745 case 1: v(select_id_E_RABs_Admitted_ToBeModified_ModAckItem()); return true;
9750 template<typename V> bool encode(size_t index, V& v) const
9752 if(index != type) return false;
9755 case 1: v(var.as<E_RABs_Admitted_ToBeModified_ModAckItem>()); return true;
9761 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9762 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9765 char dummy1[sizeof(E_RABs_Admitted_ToBeModified_ModAckItem)];
9768 asn::variant<sizeof(union_type)> var;
9772 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
9774 size_t get_index() const {return type;}
9775 void clear() {type = 0;}
9776 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(mandatory); type=1;}
9777 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
9778 template<typename V> bool decode(V& v)
9781 if(!v(ref_nested())) return false;
9782 if(equal(mandatory)) { type = 1; return true; }
9786 template<typename V> bool encode(V& v) const
9788 return v(ref_nested());
9792 template<typename V> bool decode(size_t index, V& v)
9797 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
9798 ref_nested().clear();
9803 template<typename V> bool encode(size_t index, V& v) const
9805 if(index != type) {return false;} return v(ref_nested());
9815 E-RABs-Admitted-ToBeModified-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-ModAckItemIEs} }
9818 struct E_RABs_Admitted_ToBeModified_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>
9820 static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_ModAckList_elm";}
9821 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>;
9824 struct E_RABs_Admitted_ToBeModified_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>
9826 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckList";}
9827 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>;
9828 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
9832 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9833 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
9834 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional},
9839 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs
9841 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9843 size_t get_index() const {return type;}
9844 bool is_unknown() const { return type == 3; }
9845 void clear() {type = 0;}
9846 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
9847 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
9848 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9849 template<typename V> bool decode(V& v)
9852 if(!v(ref_nested())) return false;
9853 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
9854 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
9855 else { type = 3; return true;}
9859 template<typename V> bool encode(V& v) const
9861 return v(ref_nested());
9865 template<typename V> bool decode(size_t index, V& v)
9870 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
9871 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
9872 case 3: type = 3; return v(ref_nested());
9873 ref_nested().clear();
9878 template<typename V> bool encode(size_t index, V& v) const
9880 if(index != type) {return false;} return v(ref_nested());
9887 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9889 size_t get_index() const {return type;}
9890 bool is_unknown() const { return type == 3; }
9891 void clear() {type = 0;}
9892 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
9893 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
9894 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9895 template<typename V> bool decode(V& v)
9898 if(!v(ref_nested())) return false;
9899 if(equal(ignore)) { type = 1; return true; }
9900 else if(equal(ignore)) { type = 2; return true; }
9901 else { type = 3; return true;}
9905 template<typename V> bool encode(V& v) const
9907 return v(ref_nested());
9911 template<typename V> bool decode(size_t index, V& v)
9916 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
9917 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
9918 case 3: type = 3; return v(ref_nested());
9919 ref_nested().clear();
9924 template<typename V> bool encode(size_t index, V& v) const
9926 if(index != type) {return false;} return v(ref_nested());
9933 struct Extension_t : asn::typefield<true>
9935 ~Extension_t() {clear();}
9936 size_t get_index() const {return type;}
9937 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
9938 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
9939 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
9940 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
9941 bool is_unknown() const { return type == 3; }
9946 case 1: var.destroy<PDCPSnLength>(); break;
9947 case 2: var.destroy<PDCPSnLength>(); break;
9949 type = 0; ref_nested().clear();
9951 template<typename V> static inline void enumerate(V& v)
9953 v.template operator()<PDCPSnLength>(1);
9954 v.template operator()<PDCPSnLength>(2);
9958 template<typename V> bool decode(size_t index, V& v)
9963 case 1: v(select_id_uLpDCPSnLength()); return true;
9964 case 2: v(select_id_dLPDCPSnLength()); return true;
9965 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
9970 template<typename V> bool encode(size_t index, V& v) const
9972 if(index != type) return false;
9975 case 1: v(var.as<PDCPSnLength>()); return true;
9976 case 2: v(var.as<PDCPSnLength>()); return true;
9982 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9983 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9986 char dummy1[sizeof(PDCPSnLength)];
9989 asn::variant<sizeof(union_type)> var;
9993 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9995 size_t get_index() const {return type;}
9996 bool is_unknown() const { return type == 3; }
9997 void clear() {type = 0;}
9998 void select_id_uLpDCPSnLength() { set(optional); type=1;}
9999 void select_id_dLPDCPSnLength() { set(optional); type=2;}
10000 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10001 template<typename V> bool decode(V& v)
10004 if(!v(ref_nested())) return false;
10005 if(equal(optional)) { type = 1; return true; }
10006 else if(equal(optional)) { type = 2; return true; }
10007 else { type = 3; return true;}
10011 template<typename V> bool encode(V& v) const
10013 return v(ref_nested());
10017 template<typename V> bool decode(size_t index, V& v)
10022 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
10023 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
10024 case 3: type = 3; return v(ref_nested());
10025 ref_nested().clear();
10030 template<typename V> bool encode(size_t index, V& v) const
10032 if(index != type) {return false;} return v(ref_nested());
10042 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
10043 s1-DL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
10044 sgNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
10045 mCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
10046 uL-Configuration ULConfiguration OPTIONAL,
10047 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
10052 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
10054 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent";}
10055 using parent_t = asn::sequence<5, 0, true, 5>;
10056 struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
10058 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
10059 using parent_t = GTPtunnelEndpoint;
10060 static constexpr bool optional = true;
10063 s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
10064 s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
10065 struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
10067 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
10068 using parent_t = GTPtunnelEndpoint;
10069 static constexpr bool optional = true;
10072 sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
10073 sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
10074 struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
10076 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
10077 using parent_t = E_RAB_Level_QoS_Parameters;
10078 static constexpr bool optional = true;
10081 mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
10082 mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
10083 struct uL_Configuration_t : ULConfiguration
10085 static constexpr const char* name() {return "uL_Configuration_t";}
10086 using parent_t = ULConfiguration;
10087 static constexpr bool optional = true;
10090 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
10091 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
10092 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
10094 static constexpr const char* name() {return "iE_Extensions_t";}
10095 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
10096 static constexpr bool optional = true;
10099 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10100 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10101 template<typename V> void decode(V& v)
10103 v(s1_DL_GTPtunnelEndpoint);
10104 v(sgNB_UL_GTP_TEIDatPDCP);
10105 v(mCG_E_RAB_Level_QoS_Parameters);
10106 v(uL_Configuration);
10110 template<typename V> void encode(V& v) const
10112 v(s1_DL_GTPtunnelEndpoint);
10113 v(sgNB_UL_GTP_TEIDatPDCP);
10114 v(mCG_E_RAB_Level_QoS_Parameters);
10115 v(uL_Configuration);
10121 s1_DL_GTPtunnelEndpoint.clear();
10122 sgNB_UL_GTP_TEIDatPDCP.clear();
10123 mCG_E_RAB_Level_QoS_Parameters.clear();
10124 uL_Configuration.clear();
10125 iE_Extensions.clear();
10129 s1_DL_GTPtunnelEndpoint_t s1_DL_GTPtunnelEndpoint;
10130 sgNB_UL_GTP_TEIDatPDCP_t sgNB_UL_GTP_TEIDatPDCP;
10131 mCG_E_RAB_Level_QoS_Parameters_t mCG_E_RAB_Level_QoS_Parameters;
10132 uL_Configuration_t uL_Configuration;
10133 iE_Extensions_t iE_Extensions;
10137 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10138 { ID id-secondarysgNBDLGTPTEIDatPDCP CRITICALITY ignore EXTENSION GTPtunnelEndpoint PRESENCE optional}|
10139 { ID id-RLC-Status CRITICALITY ignore EXTENSION RLC-Status PRESENCE optional },
10144 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
10146 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10148 size_t get_index() const {return type;}
10149 bool is_unknown() const { return type == 3; }
10150 void clear() {type = 0;}
10151 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(id_secondarysgNBDLGTPTEIDatPDCP); type=1;}
10152 void select_id_RLC_Status() { set(id_RLC_Status); type=2;}
10153 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10154 template<typename V> bool decode(V& v)
10157 if(!v(ref_nested())) return false;
10158 if(equal(id_secondarysgNBDLGTPTEIDatPDCP)) { type = 1; return true; }
10159 else if(equal(id_RLC_Status)) { type = 2; return true; }
10160 else { type = 3; return true;}
10164 template<typename V> bool encode(V& v) const
10166 return v(ref_nested());
10170 template<typename V> bool decode(size_t index, V& v)
10175 case 1: type = 1; if(v(ref_nested())) { return equal(id_secondarysgNBDLGTPTEIDatPDCP);} return false;
10176 case 2: type = 2; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
10177 case 3: type = 3; return v(ref_nested());
10178 ref_nested().clear();
10183 template<typename V> bool encode(size_t index, V& v) const
10185 if(index != type) {return false;} return v(ref_nested());
10192 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10194 size_t get_index() const {return type;}
10195 bool is_unknown() const { return type == 3; }
10196 void clear() {type = 0;}
10197 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(ignore); type=1;}
10198 void select_id_RLC_Status() { set(ignore); type=2;}
10199 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10200 template<typename V> bool decode(V& v)
10203 if(!v(ref_nested())) return false;
10204 if(equal(ignore)) { type = 1; return true; }
10205 else if(equal(ignore)) { type = 2; return true; }
10206 else { type = 3; return true;}
10210 template<typename V> bool encode(V& v) const
10212 return v(ref_nested());
10216 template<typename V> bool decode(size_t index, V& v)
10221 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
10222 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
10223 case 3: type = 3; return v(ref_nested());
10224 ref_nested().clear();
10229 template<typename V> bool encode(size_t index, V& v) const
10231 if(index != type) {return false;} return v(ref_nested());
10238 struct Extension_t : asn::typefield<true>
10240 ~Extension_t() {clear();}
10241 size_t get_index() const {return type;}
10242 GTPtunnelEndpoint& select_id_secondarysgNBDLGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(1); }
10243 GTPtunnelEndpoint const* get_id_secondarysgNBDLGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(1); }
10244 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(2); }
10245 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(2); }
10246 bool is_unknown() const { return type == 3; }
10251 case 1: var.destroy<GTPtunnelEndpoint>(); break;
10252 case 2: var.destroy<RLC_Status>(); break;
10254 type = 0; ref_nested().clear();
10256 template<typename V> static inline void enumerate(V& v)
10258 v.template operator()<GTPtunnelEndpoint>(1);
10259 v.template operator()<RLC_Status>(2);
10263 template<typename V> bool decode(size_t index, V& v)
10268 case 1: v(select_id_secondarysgNBDLGTPTEIDatPDCP()); return true;
10269 case 2: v(select_id_RLC_Status()); return true;
10270 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
10275 template<typename V> bool encode(size_t index, V& v) const
10277 if(index != type) return false;
10280 case 1: v(var.as<GTPtunnelEndpoint>()); return true;
10281 case 2: v(var.as<RLC_Status>()); return true;
10287 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
10288 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
10291 char dummy1[sizeof(GTPtunnelEndpoint)];
10292 char dummy2[sizeof(RLC_Status)];
10295 asn::variant<sizeof(union_type)> var;
10299 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10301 size_t get_index() const {return type;}
10302 bool is_unknown() const { return type == 3; }
10303 void clear() {type = 0;}
10304 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(optional); type=1;}
10305 void select_id_RLC_Status() { set(optional); type=2;}
10306 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10307 template<typename V> bool decode(V& v)
10310 if(!v(ref_nested())) return false;
10311 if(equal(optional)) { type = 1; return true; }
10312 else if(equal(optional)) { type = 2; return true; }
10313 else { type = 3; return true;}
10317 template<typename V> bool encode(V& v) const
10319 return v(ref_nested());
10323 template<typename V> bool decode(size_t index, V& v)
10328 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
10329 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
10330 case 3: type = 3; return v(ref_nested());
10331 ref_nested().clear();
10336 template<typename V> bool encode(size_t index, V& v) const
10338 if(index != type) {return false;} return v(ref_nested());
10348 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
10349 sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint OPTIONAL,
10350 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
10355 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
10357 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent";}
10358 using parent_t = asn::sequence<2, 0, true, 2>;
10359 struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
10361 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
10362 using parent_t = GTPtunnelEndpoint;
10363 static constexpr bool optional = true;
10366 sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
10367 sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
10368 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
10370 static constexpr const char* name() {return "iE_Extensions_t";}
10371 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
10372 static constexpr bool optional = true;
10375 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10376 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10377 template<typename V> void decode(V& v)
10379 v(sgNB_DL_GTP_TEIDatSCG);
10383 template<typename V> void encode(V& v) const
10385 v(sgNB_DL_GTP_TEIDatSCG);
10391 sgNB_DL_GTP_TEIDatSCG.clear();
10392 iE_Extensions.clear();
10396 sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
10397 iE_Extensions_t iE_Extensions;
10401 E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10406 struct E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs
10408 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10410 size_t get_index() const {return type;}
10411 bool is_unknown() const { return type == 1; }
10412 void clear() {type = 0;}
10413 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10414 template<typename V> bool decode(V& v)
10417 if(!v(ref_nested())) return false;
10418 { type = 1; return true;}
10422 template<typename V> bool encode(V& v) const
10424 return v(ref_nested());
10428 template<typename V> bool decode(size_t index, V& v)
10433 case 1: type = 1; return v(ref_nested());
10434 ref_nested().clear();
10439 template<typename V> bool encode(size_t index, V& v) const
10441 if(index != type) {return false;} return v(ref_nested());
10448 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10450 size_t get_index() const {return type;}
10451 bool is_unknown() const { return type == 1; }
10452 void clear() {type = 0;}
10453 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10454 template<typename V> bool decode(V& v)
10457 if(!v(ref_nested())) return false;
10458 { type = 1; return true;}
10462 template<typename V> bool encode(V& v) const
10464 return v(ref_nested());
10468 template<typename V> bool decode(size_t index, V& v)
10473 case 1: type = 1; return v(ref_nested());
10474 ref_nested().clear();
10479 template<typename V> bool encode(size_t index, V& v) const
10481 if(index != type) {return false;} return v(ref_nested());
10488 struct Extension_t : asn::typefield<true>
10490 ~Extension_t() {clear();}
10491 size_t get_index() const {return type;}
10492 bool is_unknown() const { return type == 1; }
10495 type = 0; ref_nested().clear();
10497 template<typename V> static inline void enumerate(V& v)
10502 template<typename V> bool decode(size_t index, V& v)
10507 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10512 template<typename V> bool encode(size_t index, V& v) const
10514 if(index != type) return false;
10522 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10524 size_t get_index() const {return type;}
10525 bool is_unknown() const { return type == 1; }
10526 void clear() {type = 0;}
10527 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10528 template<typename V> bool decode(V& v)
10531 if(!v(ref_nested())) return false;
10532 { type = 1; return true;}
10536 template<typename V> bool encode(V& v) const
10538 return v(ref_nested());
10542 template<typename V> bool decode(size_t index, V& v)
10547 case 1: type = 1; return v(ref_nested());
10548 ref_nested().clear();
10553 template<typename V> bool encode(size_t index, V& v) const
10555 if(index != type) {return false;} return v(ref_nested());
10565 E-RABs-Admitted-ToBeModified-SgNBModAck-Item ::= SEQUENCE {
10567 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
10568 resource-configuration CHOICE {
10569 sgNBPDCPpresent E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent,
10570 sgNBPDCPnotpresent E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent,
10573 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs} } OPTIONAL,
10578 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
10580 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item";}
10581 using parent_t = asn::sequence<4, 0, true, 1>;
10582 struct e_RAB_ID_t : E_RAB_ID
10584 static constexpr const char* name() {return "e_RAB_ID_t";}
10585 using parent_t = E_RAB_ID;
10588 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
10589 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
10590 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
10592 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
10593 using parent_t = EN_DC_ResourceConfiguration;
10596 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
10597 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
10598 struct resource_configuration_t : asn::choice<2, 0, true>
10600 static constexpr const char* name() {return "resource_configuration_t";}
10601 using parent_t = asn::choice<2, 0, true>;
10602 index_type get_index() const {return index;}
10603 bool is_unknown() const {return index == 3;}
10604 void set_unknown() { set_index(3); }
10605 ~resource_configuration_t() {clear();}
10606 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent
10608 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
10609 using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent;
10612 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent
10614 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
10615 using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent;
10620 switch(get_index())
10622 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
10623 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
10628 template<typename V> bool decode(size_t idx, V& v)
10633 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
10634 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
10639 template<typename V> bool encode(V& v) const
10641 switch(get_index())
10643 case 1: return v(var.as<sgNBPDCPpresent_t>());
10644 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
10648 template<typename V> static inline void enumerate(V& v)
10650 v.template operator()<sgNBPDCPpresent_t>(1);
10651 v.template operator()<sgNBPDCPnotpresent_t>(2);
10654 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
10655 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
10656 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
10657 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
10659 void set_index(index_type i) {index = i; base::set();}
10662 char dummy1[sizeof(sgNBPDCPpresent_t)];
10663 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
10666 asn::variant<sizeof(union_type)> var;
10667 index_type index {0};
10669 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
10670 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
10671 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>
10673 static constexpr const char* name() {return "iE_Extensions_t";}
10674 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>;
10675 static constexpr bool optional = true;
10678 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10679 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10680 template<typename V> void decode(V& v)
10683 v(en_DC_ResourceConfiguration);
10684 v(resource_configuration);
10688 template<typename V> void encode(V& v) const
10691 v(en_DC_ResourceConfiguration);
10692 v(resource_configuration);
10699 en_DC_ResourceConfiguration.clear();
10700 resource_configuration.clear();
10701 iE_Extensions.clear();
10705 e_RAB_ID_t e_RAB_ID;
10706 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
10707 resource_configuration_t resource_configuration;
10708 iE_Extensions_t iE_Extensions;
10712 E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
10713 { ID id-E-RABs-Admitted-ToBeModified-SgNBModAck-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToBeModified-SgNBModAck-Item PRESENCE mandatory}
10717 struct E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs
10719 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
10721 size_t get_index() const {return type;}
10722 void clear() {type = 0;}
10723 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item); type=1;}
10724 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
10725 template<typename V> bool decode(V& v)
10728 if(!v(ref_nested())) return false;
10729 if(equal(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item)) { type = 1; return true; }
10733 template<typename V> bool encode(V& v) const
10735 return v(ref_nested());
10739 template<typename V> bool decode(size_t index, V& v)
10744 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item);} return false;
10745 ref_nested().clear();
10750 template<typename V> bool encode(size_t index, V& v) const
10752 if(index != type) {return false;} return v(ref_nested());
10759 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
10761 size_t get_index() const {return type;}
10762 void clear() {type = 0;}
10763 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(ignore); type=1;}
10764 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
10765 template<typename V> bool decode(V& v)
10768 if(!v(ref_nested())) return false;
10769 if(equal(ignore)) { type = 1; return true; }
10773 template<typename V> bool encode(V& v) const
10775 return v(ref_nested());
10779 template<typename V> bool decode(size_t index, V& v)
10784 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
10785 ref_nested().clear();
10790 template<typename V> bool encode(size_t index, V& v) const
10792 if(index != type) {return false;} return v(ref_nested());
10799 struct Value_t : asn::typefield<false>
10801 ~Value_t() {clear();}
10802 size_t get_index() const {return type;}
10803 E_RABs_Admitted_ToBeModified_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
10804 E_RABs_Admitted_ToBeModified_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
10809 case 1: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(); break;
10811 type = 0; ref_nested().clear();
10813 template<typename V> static inline void enumerate(V& v)
10815 v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1);
10819 template<typename V> bool decode(size_t index, V& v)
10824 case 1: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item()); return true;
10829 template<typename V> bool encode(size_t index, V& v) const
10831 if(index != type) return false;
10834 case 1: v(var.as<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>()); return true;
10840 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
10841 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
10844 char dummy1[sizeof(E_RABs_Admitted_ToBeModified_SgNBModAck_Item)];
10847 asn::variant<sizeof(union_type)> var;
10851 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
10853 size_t get_index() const {return type;}
10854 void clear() {type = 0;}
10855 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(mandatory); type=1;}
10856 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
10857 template<typename V> bool decode(V& v)
10860 if(!v(ref_nested())) return false;
10861 if(equal(mandatory)) { type = 1; return true; }
10865 template<typename V> bool encode(V& v) const
10867 return v(ref_nested());
10871 template<typename V> bool decode(size_t index, V& v)
10876 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
10877 ref_nested().clear();
10882 template<typename V> bool encode(size_t index, V& v) const
10884 if(index != type) {return false;} return v(ref_nested());
10894 E-RABs-Admitted-ToBeModified-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs} }
10897 struct E_RABs_Admitted_ToBeModified_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>
10899 static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_SgNBModAckList_elm";}
10900 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>;
10903 struct E_RABs_Admitted_ToBeModified_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>
10905 static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAckList";}
10906 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>;
10907 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
10911 E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10916 struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs
10918 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10920 size_t get_index() const {return type;}
10921 bool is_unknown() const { return type == 1; }
10922 void clear() {type = 0;}
10923 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10924 template<typename V> bool decode(V& v)
10927 if(!v(ref_nested())) return false;
10928 { type = 1; return true;}
10932 template<typename V> bool encode(V& v) const
10934 return v(ref_nested());
10938 template<typename V> bool decode(size_t index, V& v)
10943 case 1: type = 1; return v(ref_nested());
10944 ref_nested().clear();
10949 template<typename V> bool encode(size_t index, V& v) const
10951 if(index != type) {return false;} return v(ref_nested());
10958 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10960 size_t get_index() const {return type;}
10961 bool is_unknown() const { return type == 1; }
10962 void clear() {type = 0;}
10963 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10964 template<typename V> bool decode(V& v)
10967 if(!v(ref_nested())) return false;
10968 { type = 1; return true;}
10972 template<typename V> bool encode(V& v) const
10974 return v(ref_nested());
10978 template<typename V> bool decode(size_t index, V& v)
10983 case 1: type = 1; return v(ref_nested());
10984 ref_nested().clear();
10989 template<typename V> bool encode(size_t index, V& v) const
10991 if(index != type) {return false;} return v(ref_nested());
10998 struct Extension_t : asn::typefield<true>
11000 ~Extension_t() {clear();}
11001 size_t get_index() const {return type;}
11002 bool is_unknown() const { return type == 1; }
11005 type = 0; ref_nested().clear();
11007 template<typename V> static inline void enumerate(V& v)
11012 template<typename V> bool decode(size_t index, V& v)
11017 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11022 template<typename V> bool encode(size_t index, V& v) const
11024 if(index != type) return false;
11032 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11034 size_t get_index() const {return type;}
11035 bool is_unknown() const { return type == 1; }
11036 void clear() {type = 0;}
11037 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11038 template<typename V> bool decode(V& v)
11041 if(!v(ref_nested())) return false;
11042 { type = 1; return true;}
11046 template<typename V> bool encode(V& v) const
11048 return v(ref_nested());
11052 template<typename V> bool decode(size_t index, V& v)
11057 case 1: type = 1; return v(ref_nested());
11058 ref_nested().clear();
11063 template<typename V> bool encode(size_t index, V& v) const
11065 if(index != type) {return false;} return v(ref_nested());
11075 E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer ::= SEQUENCE {
11077 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs} } OPTIONAL,
11082 struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer : asn::sequence<2, 0, true, 1>
11084 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer";}
11085 using parent_t = asn::sequence<2, 0, true, 1>;
11086 struct e_RAB_ID_t : E_RAB_ID
11088 static constexpr const char* name() {return "e_RAB_ID_t";}
11089 using parent_t = E_RAB_ID;
11092 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
11093 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
11094 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>
11096 static constexpr const char* name() {return "iE_Extensions_t";}
11097 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>;
11098 static constexpr bool optional = true;
11101 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11102 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11103 template<typename V> void decode(V& v)
11109 template<typename V> void encode(V& v) const
11118 iE_Extensions.clear();
11122 e_RAB_ID_t e_RAB_ID;
11123 iE_Extensions_t iE_Extensions;
11127 E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11132 struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs
11134 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11136 size_t get_index() const {return type;}
11137 bool is_unknown() const { return type == 1; }
11138 void clear() {type = 0;}
11139 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11140 template<typename V> bool decode(V& v)
11143 if(!v(ref_nested())) return false;
11144 { type = 1; return true;}
11148 template<typename V> bool encode(V& v) const
11150 return v(ref_nested());
11154 template<typename V> bool decode(size_t index, V& v)
11159 case 1: type = 1; return v(ref_nested());
11160 ref_nested().clear();
11165 template<typename V> bool encode(size_t index, V& v) const
11167 if(index != type) {return false;} return v(ref_nested());
11174 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11176 size_t get_index() const {return type;}
11177 bool is_unknown() const { return type == 1; }
11178 void clear() {type = 0;}
11179 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11180 template<typename V> bool decode(V& v)
11183 if(!v(ref_nested())) return false;
11184 { type = 1; return true;}
11188 template<typename V> bool encode(V& v) const
11190 return v(ref_nested());
11194 template<typename V> bool decode(size_t index, V& v)
11199 case 1: type = 1; return v(ref_nested());
11200 ref_nested().clear();
11205 template<typename V> bool encode(size_t index, V& v) const
11207 if(index != type) {return false;} return v(ref_nested());
11214 struct Extension_t : asn::typefield<true>
11216 ~Extension_t() {clear();}
11217 size_t get_index() const {return type;}
11218 bool is_unknown() const { return type == 1; }
11221 type = 0; ref_nested().clear();
11223 template<typename V> static inline void enumerate(V& v)
11228 template<typename V> bool decode(size_t index, V& v)
11233 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11238 template<typename V> bool encode(size_t index, V& v) const
11240 if(index != type) return false;
11248 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11250 size_t get_index() const {return type;}
11251 bool is_unknown() const { return type == 1; }
11252 void clear() {type = 0;}
11253 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11254 template<typename V> bool decode(V& v)
11257 if(!v(ref_nested())) return false;
11258 { type = 1; return true;}
11262 template<typename V> bool encode(V& v) const
11264 return v(ref_nested());
11268 template<typename V> bool decode(size_t index, V& v)
11273 case 1: type = 1; return v(ref_nested());
11274 ref_nested().clear();
11279 template<typename V> bool encode(size_t index, V& v) const
11281 if(index != type) {return false;} return v(ref_nested());
11291 E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer ::= SEQUENCE {
11293 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
11298 struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer : asn::sequence<2, 0, true, 1>
11300 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer";}
11301 using parent_t = asn::sequence<2, 0, true, 1>;
11302 struct e_RAB_ID_t : E_RAB_ID
11304 static constexpr const char* name() {return "e_RAB_ID_t";}
11305 using parent_t = E_RAB_ID;
11308 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
11309 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
11310 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>
11312 static constexpr const char* name() {return "iE_Extensions_t";}
11313 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>;
11314 static constexpr bool optional = true;
11317 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11318 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11319 template<typename V> void decode(V& v)
11325 template<typename V> void encode(V& v) const
11334 iE_Extensions.clear();
11338 e_RAB_ID_t e_RAB_ID;
11339 iE_Extensions_t iE_Extensions;
11343 E-RABs-Admitted-ToReleased-ModAckItem ::= CHOICE {
11344 sCG-Bearer E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer,
11345 split-Bearer E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer,
11350 struct E_RABs_Admitted_ToReleased_ModAckItem : asn::choice<2, 0, true>
11352 static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-ModAckItem";}
11353 using parent_t = asn::choice<2, 0, true>;
11354 index_type get_index() const {return index;}
11355 bool is_unknown() const {return index == 3;}
11356 void set_unknown() { set_index(3); }
11357 ~E_RABs_Admitted_ToReleased_ModAckItem() {clear();}
11358 struct sCG_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer
11360 static constexpr const char* name() {return "sCG_Bearer_t";}
11361 using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer;
11364 struct split_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer
11366 static constexpr const char* name() {return "split_Bearer_t";}
11367 using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer;
11372 switch(get_index())
11374 case 1: var.destroy<sCG_Bearer_t>(); break;
11375 case 2: var.destroy<split_Bearer_t>(); break;
11380 template<typename V> bool decode(size_t idx, V& v)
11385 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
11386 case 2: set_index(2); return v(var.build<split_Bearer_t>());
11391 template<typename V> bool encode(V& v) const
11393 switch(get_index())
11395 case 1: return v(var.as<sCG_Bearer_t>());
11396 case 2: return v(var.as<split_Bearer_t>());
11400 template<typename V> static inline void enumerate(V& v)
11402 v.template operator()<sCG_Bearer_t>(1);
11403 v.template operator()<split_Bearer_t>(2);
11406 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
11407 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
11408 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
11409 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
11411 void set_index(index_type i) {index = i; base::set();}
11414 char dummy1[sizeof(sCG_Bearer_t)];
11415 char dummy2[sizeof(split_Bearer_t)];
11418 asn::variant<sizeof(union_type)> var;
11419 index_type index {0};
11422 E-RABs-Admitted-ToBeReleased-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
11423 { ID id-E-RABs-Admitted-ToBeReleased-ModAckItem CRITICALITY ignore TYPE E-RABs-Admitted-ToReleased-ModAckItem PRESENCE mandatory}
11427 struct E_RABs_Admitted_ToBeReleased_ModAckItemIEs
11429 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
11431 size_t get_index() const {return type;}
11432 void clear() {type = 0;}
11433 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(id_E_RABs_Admitted_ToBeReleased_ModAckItem); type=1;}
11434 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
11435 template<typename V> bool decode(V& v)
11438 if(!v(ref_nested())) return false;
11439 if(equal(id_E_RABs_Admitted_ToBeReleased_ModAckItem)) { type = 1; return true; }
11443 template<typename V> bool encode(V& v) const
11445 return v(ref_nested());
11449 template<typename V> bool decode(size_t index, V& v)
11454 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_ModAckItem);} return false;
11455 ref_nested().clear();
11460 template<typename V> bool encode(size_t index, V& v) const
11462 if(index != type) {return false;} return v(ref_nested());
11469 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
11471 size_t get_index() const {return type;}
11472 void clear() {type = 0;}
11473 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(ignore); type=1;}
11474 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
11475 template<typename V> bool decode(V& v)
11478 if(!v(ref_nested())) return false;
11479 if(equal(ignore)) { type = 1; return true; }
11483 template<typename V> bool encode(V& v) const
11485 return v(ref_nested());
11489 template<typename V> bool decode(size_t index, V& v)
11494 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
11495 ref_nested().clear();
11500 template<typename V> bool encode(size_t index, V& v) const
11502 if(index != type) {return false;} return v(ref_nested());
11509 struct Value_t : asn::typefield<false>
11511 ~Value_t() {clear();}
11512 size_t get_index() const {return type;}
11513 E_RABs_Admitted_ToReleased_ModAckItem& select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { return set<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
11514 E_RABs_Admitted_ToReleased_ModAckItem const* get_id_E_RABs_Admitted_ToBeReleased_ModAckItem() const { return get<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
11519 case 1: var.destroy<E_RABs_Admitted_ToReleased_ModAckItem>(); break;
11521 type = 0; ref_nested().clear();
11523 template<typename V> static inline void enumerate(V& v)
11525 v.template operator()<E_RABs_Admitted_ToReleased_ModAckItem>(1);
11529 template<typename V> bool decode(size_t index, V& v)
11534 case 1: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckItem()); return true;
11539 template<typename V> bool encode(size_t index, V& v) const
11541 if(index != type) return false;
11544 case 1: v(var.as<E_RABs_Admitted_ToReleased_ModAckItem>()); return true;
11550 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
11551 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
11554 char dummy1[sizeof(E_RABs_Admitted_ToReleased_ModAckItem)];
11557 asn::variant<sizeof(union_type)> var;
11561 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
11563 size_t get_index() const {return type;}
11564 void clear() {type = 0;}
11565 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(mandatory); type=1;}
11566 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
11567 template<typename V> bool decode(V& v)
11570 if(!v(ref_nested())) return false;
11571 if(equal(mandatory)) { type = 1; return true; }
11575 template<typename V> bool encode(V& v) const
11577 return v(ref_nested());
11581 template<typename V> bool decode(size_t index, V& v)
11586 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
11587 ref_nested().clear();
11592 template<typename V> bool encode(size_t index, V& v) const
11594 if(index != type) {return false;} return v(ref_nested());
11604 E-RABs-Admitted-ToBeReleased-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-ModAckItemIEs} }
11607 struct E_RABs_Admitted_ToBeReleased_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>
11609 static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_ModAckList_elm";}
11610 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>;
11613 struct E_RABs_Admitted_ToBeReleased_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>
11615 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckList";}
11616 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>;
11617 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
11621 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11626 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
11628 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11630 size_t get_index() const {return type;}
11631 bool is_unknown() const { return type == 1; }
11632 void clear() {type = 0;}
11633 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11634 template<typename V> bool decode(V& v)
11637 if(!v(ref_nested())) return false;
11638 { type = 1; return true;}
11642 template<typename V> bool encode(V& v) const
11644 return v(ref_nested());
11648 template<typename V> bool decode(size_t index, V& v)
11653 case 1: type = 1; return v(ref_nested());
11654 ref_nested().clear();
11659 template<typename V> bool encode(size_t index, V& v) const
11661 if(index != type) {return false;} return v(ref_nested());
11668 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11670 size_t get_index() const {return type;}
11671 bool is_unknown() const { return type == 1; }
11672 void clear() {type = 0;}
11673 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11674 template<typename V> bool decode(V& v)
11677 if(!v(ref_nested())) return false;
11678 { type = 1; return true;}
11682 template<typename V> bool encode(V& v) const
11684 return v(ref_nested());
11688 template<typename V> bool decode(size_t index, V& v)
11693 case 1: type = 1; return v(ref_nested());
11694 ref_nested().clear();
11699 template<typename V> bool encode(size_t index, V& v) const
11701 if(index != type) {return false;} return v(ref_nested());
11708 struct Extension_t : asn::typefield<true>
11710 ~Extension_t() {clear();}
11711 size_t get_index() const {return type;}
11712 bool is_unknown() const { return type == 1; }
11715 type = 0; ref_nested().clear();
11717 template<typename V> static inline void enumerate(V& v)
11722 template<typename V> bool decode(size_t index, V& v)
11727 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11732 template<typename V> bool encode(size_t index, V& v) const
11734 if(index != type) return false;
11742 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11744 size_t get_index() const {return type;}
11745 bool is_unknown() const { return type == 1; }
11746 void clear() {type = 0;}
11747 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11748 template<typename V> bool decode(V& v)
11751 if(!v(ref_nested())) return false;
11752 { type = 1; return true;}
11756 template<typename V> bool encode(V& v) const
11758 return v(ref_nested());
11762 template<typename V> bool decode(size_t index, V& v)
11767 case 1: type = 1; return v(ref_nested());
11768 ref_nested().clear();
11773 template<typename V> bool encode(size_t index, V& v) const
11775 if(index != type) {return false;} return v(ref_nested());
11785 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
11786 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
11791 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
11793 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent";}
11794 using parent_t = asn::sequence<1, 0, true, 1>;
11795 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
11797 static constexpr const char* name() {return "iE_Extensions_t";}
11798 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
11799 static constexpr bool optional = true;
11802 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11803 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11804 template<typename V> void decode(V& v)
11809 template<typename V> void encode(V& v) const
11816 iE_Extensions.clear();
11820 iE_Extensions_t iE_Extensions;
11824 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11829 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs
11831 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11833 size_t get_index() const {return type;}
11834 bool is_unknown() const { return type == 1; }
11835 void clear() {type = 0;}
11836 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11837 template<typename V> bool decode(V& v)
11840 if(!v(ref_nested())) return false;
11841 { type = 1; return true;}
11845 template<typename V> bool encode(V& v) const
11847 return v(ref_nested());
11851 template<typename V> bool decode(size_t index, V& v)
11856 case 1: type = 1; return v(ref_nested());
11857 ref_nested().clear();
11862 template<typename V> bool encode(size_t index, V& v) const
11864 if(index != type) {return false;} return v(ref_nested());
11871 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11873 size_t get_index() const {return type;}
11874 bool is_unknown() const { return type == 1; }
11875 void clear() {type = 0;}
11876 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11877 template<typename V> bool decode(V& v)
11880 if(!v(ref_nested())) return false;
11881 { type = 1; return true;}
11885 template<typename V> bool encode(V& v) const
11887 return v(ref_nested());
11891 template<typename V> bool decode(size_t index, V& v)
11896 case 1: type = 1; return v(ref_nested());
11897 ref_nested().clear();
11902 template<typename V> bool encode(size_t index, V& v) const
11904 if(index != type) {return false;} return v(ref_nested());
11911 struct Extension_t : asn::typefield<true>
11913 ~Extension_t() {clear();}
11914 size_t get_index() const {return type;}
11915 bool is_unknown() const { return type == 1; }
11918 type = 0; ref_nested().clear();
11920 template<typename V> static inline void enumerate(V& v)
11925 template<typename V> bool decode(size_t index, V& v)
11930 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11935 template<typename V> bool encode(size_t index, V& v) const
11937 if(index != type) return false;
11945 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11947 size_t get_index() const {return type;}
11948 bool is_unknown() const { return type == 1; }
11949 void clear() {type = 0;}
11950 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11951 template<typename V> bool decode(V& v)
11954 if(!v(ref_nested())) return false;
11955 { type = 1; return true;}
11959 template<typename V> bool encode(V& v) const
11961 return v(ref_nested());
11965 template<typename V> bool decode(size_t index, V& v)
11970 case 1: type = 1; return v(ref_nested());
11971 ref_nested().clear();
11976 template<typename V> bool encode(size_t index, V& v) const
11978 if(index != type) {return false;} return v(ref_nested());
11988 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
11989 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
11994 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
11996 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent";}
11997 using parent_t = asn::sequence<1, 0, true, 1>;
11998 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
12000 static constexpr const char* name() {return "iE_Extensions_t";}
12001 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
12002 static constexpr bool optional = true;
12005 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12006 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12007 template<typename V> void decode(V& v)
12012 template<typename V> void encode(V& v) const
12019 iE_Extensions.clear();
12023 iE_Extensions_t iE_Extensions;
12027 E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12032 struct E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs
12034 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12036 size_t get_index() const {return type;}
12037 bool is_unknown() const { return type == 1; }
12038 void clear() {type = 0;}
12039 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12040 template<typename V> bool decode(V& v)
12043 if(!v(ref_nested())) return false;
12044 { type = 1; return true;}
12048 template<typename V> bool encode(V& v) const
12050 return v(ref_nested());
12054 template<typename V> bool decode(size_t index, V& v)
12059 case 1: type = 1; return v(ref_nested());
12060 ref_nested().clear();
12065 template<typename V> bool encode(size_t index, V& v) const
12067 if(index != type) {return false;} return v(ref_nested());
12074 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12076 size_t get_index() const {return type;}
12077 bool is_unknown() const { return type == 1; }
12078 void clear() {type = 0;}
12079 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12080 template<typename V> bool decode(V& v)
12083 if(!v(ref_nested())) return false;
12084 { type = 1; return true;}
12088 template<typename V> bool encode(V& v) const
12090 return v(ref_nested());
12094 template<typename V> bool decode(size_t index, V& v)
12099 case 1: type = 1; return v(ref_nested());
12100 ref_nested().clear();
12105 template<typename V> bool encode(size_t index, V& v) const
12107 if(index != type) {return false;} return v(ref_nested());
12114 struct Extension_t : asn::typefield<true>
12116 ~Extension_t() {clear();}
12117 size_t get_index() const {return type;}
12118 bool is_unknown() const { return type == 1; }
12121 type = 0; ref_nested().clear();
12123 template<typename V> static inline void enumerate(V& v)
12128 template<typename V> bool decode(size_t index, V& v)
12133 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12138 template<typename V> bool encode(size_t index, V& v) const
12140 if(index != type) return false;
12148 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12150 size_t get_index() const {return type;}
12151 bool is_unknown() const { return type == 1; }
12152 void clear() {type = 0;}
12153 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12154 template<typename V> bool decode(V& v)
12157 if(!v(ref_nested())) return false;
12158 { type = 1; return true;}
12162 template<typename V> bool encode(V& v) const
12164 return v(ref_nested());
12168 template<typename V> bool decode(size_t index, V& v)
12173 case 1: type = 1; return v(ref_nested());
12174 ref_nested().clear();
12179 template<typename V> bool encode(size_t index, V& v) const
12181 if(index != type) {return false;} return v(ref_nested());
12191 E-RABs-Admitted-ToReleased-SgNBModAck-Item ::= SEQUENCE {
12193 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
12194 resource-configuration CHOICE {
12195 sgNBPDCPpresent E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent,
12196 sgNBPDCPnotpresent E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent,
12199 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs} } OPTIONAL,
12204 struct E_RABs_Admitted_ToReleased_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
12206 static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-SgNBModAck-Item";}
12207 using parent_t = asn::sequence<4, 0, true, 1>;
12208 struct e_RAB_ID_t : E_RAB_ID
12210 static constexpr const char* name() {return "e_RAB_ID_t";}
12211 using parent_t = E_RAB_ID;
12214 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
12215 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
12216 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
12218 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
12219 using parent_t = EN_DC_ResourceConfiguration;
12222 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
12223 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
12224 struct resource_configuration_t : asn::choice<2, 0, true>
12226 static constexpr const char* name() {return "resource_configuration_t";}
12227 using parent_t = asn::choice<2, 0, true>;
12228 index_type get_index() const {return index;}
12229 bool is_unknown() const {return index == 3;}
12230 void set_unknown() { set_index(3); }
12231 ~resource_configuration_t() {clear();}
12232 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent
12234 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
12235 using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent;
12238 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent
12240 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
12241 using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent;
12246 switch(get_index())
12248 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
12249 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
12254 template<typename V> bool decode(size_t idx, V& v)
12259 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
12260 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
12265 template<typename V> bool encode(V& v) const
12267 switch(get_index())
12269 case 1: return v(var.as<sgNBPDCPpresent_t>());
12270 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
12274 template<typename V> static inline void enumerate(V& v)
12276 v.template operator()<sgNBPDCPpresent_t>(1);
12277 v.template operator()<sgNBPDCPnotpresent_t>(2);
12280 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
12281 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
12282 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
12283 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
12285 void set_index(index_type i) {index = i; base::set();}
12288 char dummy1[sizeof(sgNBPDCPpresent_t)];
12289 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
12292 asn::variant<sizeof(union_type)> var;
12293 index_type index {0};
12295 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
12296 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
12297 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>
12299 static constexpr const char* name() {return "iE_Extensions_t";}
12300 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>;
12301 static constexpr bool optional = true;
12304 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12305 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12306 template<typename V> void decode(V& v)
12309 v(en_DC_ResourceConfiguration);
12310 v(resource_configuration);
12314 template<typename V> void encode(V& v) const
12317 v(en_DC_ResourceConfiguration);
12318 v(resource_configuration);
12325 en_DC_ResourceConfiguration.clear();
12326 resource_configuration.clear();
12327 iE_Extensions.clear();
12331 e_RAB_ID_t e_RAB_ID;
12332 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
12333 resource_configuration_t resource_configuration;
12334 iE_Extensions_t iE_Extensions;
12338 E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
12339 { ID id-E-RABs-Admitted-ToBeReleased-SgNBModAck-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToReleased-SgNBModAck-Item PRESENCE mandatory}
12343 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs
12345 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
12347 size_t get_index() const {return type;}
12348 void clear() {type = 0;}
12349 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item); type=1;}
12350 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
12351 template<typename V> bool decode(V& v)
12354 if(!v(ref_nested())) return false;
12355 if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item)) { type = 1; return true; }
12359 template<typename V> bool encode(V& v) const
12361 return v(ref_nested());
12365 template<typename V> bool decode(size_t index, V& v)
12370 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item);} return false;
12371 ref_nested().clear();
12376 template<typename V> bool encode(size_t index, V& v) const
12378 if(index != type) {return false;} return v(ref_nested());
12385 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
12387 size_t get_index() const {return type;}
12388 void clear() {type = 0;}
12389 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(ignore); type=1;}
12390 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
12391 template<typename V> bool decode(V& v)
12394 if(!v(ref_nested())) return false;
12395 if(equal(ignore)) { type = 1; return true; }
12399 template<typename V> bool encode(V& v) const
12401 return v(ref_nested());
12405 template<typename V> bool decode(size_t index, V& v)
12410 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
12411 ref_nested().clear();
12416 template<typename V> bool encode(size_t index, V& v) const
12418 if(index != type) {return false;} return v(ref_nested());
12425 struct Value_t : asn::typefield<false>
12427 ~Value_t() {clear();}
12428 size_t get_index() const {return type;}
12429 E_RABs_Admitted_ToReleased_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { return set<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
12430 E_RABs_Admitted_ToReleased_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
12435 case 1: var.destroy<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(); break;
12437 type = 0; ref_nested().clear();
12439 template<typename V> static inline void enumerate(V& v)
12441 v.template operator()<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1);
12445 template<typename V> bool decode(size_t index, V& v)
12450 case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item()); return true;
12455 template<typename V> bool encode(size_t index, V& v) const
12457 if(index != type) return false;
12460 case 1: v(var.as<E_RABs_Admitted_ToReleased_SgNBModAck_Item>()); return true;
12466 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
12467 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
12470 char dummy1[sizeof(E_RABs_Admitted_ToReleased_SgNBModAck_Item)];
12473 asn::variant<sizeof(union_type)> var;
12477 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
12479 size_t get_index() const {return type;}
12480 void clear() {type = 0;}
12481 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(mandatory); type=1;}
12482 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
12483 template<typename V> bool decode(V& v)
12486 if(!v(ref_nested())) return false;
12487 if(equal(mandatory)) { type = 1; return true; }
12491 template<typename V> bool encode(V& v) const
12493 return v(ref_nested());
12497 template<typename V> bool decode(size_t index, V& v)
12502 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
12503 ref_nested().clear();
12508 template<typename V> bool encode(size_t index, V& v) const
12510 if(index != type) {return false;} return v(ref_nested());
12520 E-RABs-Admitted-ToBeReleased-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs} }
12523 struct E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>
12525 static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm";}
12526 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>;
12529 struct E_RABs_Admitted_ToBeReleased_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>
12531 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAckList";}
12532 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>;
12533 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
12537 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12542 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs
12544 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12546 size_t get_index() const {return type;}
12547 bool is_unknown() const { return type == 1; }
12548 void clear() {type = 0;}
12549 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12550 template<typename V> bool decode(V& v)
12553 if(!v(ref_nested())) return false;
12554 { type = 1; return true;}
12558 template<typename V> bool encode(V& v) const
12560 return v(ref_nested());
12564 template<typename V> bool decode(size_t index, V& v)
12569 case 1: type = 1; return v(ref_nested());
12570 ref_nested().clear();
12575 template<typename V> bool encode(size_t index, V& v) const
12577 if(index != type) {return false;} return v(ref_nested());
12584 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12586 size_t get_index() const {return type;}
12587 bool is_unknown() const { return type == 1; }
12588 void clear() {type = 0;}
12589 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12590 template<typename V> bool decode(V& v)
12593 if(!v(ref_nested())) return false;
12594 { type = 1; return true;}
12598 template<typename V> bool encode(V& v) const
12600 return v(ref_nested());
12604 template<typename V> bool decode(size_t index, V& v)
12609 case 1: type = 1; return v(ref_nested());
12610 ref_nested().clear();
12615 template<typename V> bool encode(size_t index, V& v) const
12617 if(index != type) {return false;} return v(ref_nested());
12624 struct Extension_t : asn::typefield<true>
12626 ~Extension_t() {clear();}
12627 size_t get_index() const {return type;}
12628 bool is_unknown() const { return type == 1; }
12631 type = 0; ref_nested().clear();
12633 template<typename V> static inline void enumerate(V& v)
12638 template<typename V> bool decode(size_t index, V& v)
12643 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12648 template<typename V> bool encode(size_t index, V& v) const
12650 if(index != type) return false;
12658 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12660 size_t get_index() const {return type;}
12661 bool is_unknown() const { return type == 1; }
12662 void clear() {type = 0;}
12663 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12664 template<typename V> bool decode(V& v)
12667 if(!v(ref_nested())) return false;
12668 { type = 1; return true;}
12672 template<typename V> bool encode(V& v) const
12674 return v(ref_nested());
12678 template<typename V> bool decode(size_t index, V& v)
12683 case 1: type = 1; return v(ref_nested());
12684 ref_nested().clear();
12689 template<typename V> bool encode(size_t index, V& v) const
12691 if(index != type) {return false;} return v(ref_nested());
12701 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item ::= SEQUENCE {
12703 rlc-Mode-transferred RLCMode,
12704 iE-Extensions ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs} } OPTIONAL,
12709 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item : asn::sequence<3, 0, true, 1>
12711 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item";}
12712 using parent_t = asn::sequence<3, 0, true, 1>;
12713 struct e_RAB_ID_t : E_RAB_ID
12715 static constexpr const char* name() {return "e_RAB_ID_t";}
12716 using parent_t = E_RAB_ID;
12719 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
12720 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
12721 struct rlc_Mode_transferred_t : RLCMode
12723 static constexpr const char* name() {return "rlc_Mode_transferred_t";}
12724 using parent_t = RLCMode;
12727 rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
12728 rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
12729 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>
12731 static constexpr const char* name() {return "iE_Extensions_t";}
12732 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>;
12733 static constexpr bool optional = true;
12736 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12737 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12738 template<typename V> void decode(V& v)
12741 v(rlc_Mode_transferred);
12745 template<typename V> void encode(V& v) const
12748 v(rlc_Mode_transferred);
12755 rlc_Mode_transferred.clear();
12756 iE_Extensions.clear();
12760 e_RAB_ID_t e_RAB_ID;
12761 rlc_Mode_transferred_t rlc_Mode_transferred;
12762 iE_Extensions_t iE_Extensions;
12766 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
12767 { ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item CRITICALITY ignore TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item PRESENCE mandatory},
12772 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs
12774 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
12776 size_t get_index() const {return type;}
12777 bool is_unknown() const { return type == 2; }
12778 void clear() {type = 0;}
12779 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item); type=1;}
12780 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
12781 template<typename V> bool decode(V& v)
12784 if(!v(ref_nested())) return false;
12785 if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item)) { type = 1; return true; }
12786 else { type = 2; return true;}
12790 template<typename V> bool encode(V& v) const
12792 return v(ref_nested());
12796 template<typename V> bool decode(size_t index, V& v)
12801 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item);} return false;
12802 case 2: type = 2; return v(ref_nested());
12803 ref_nested().clear();
12808 template<typename V> bool encode(size_t index, V& v) const
12810 if(index != type) {return false;} return v(ref_nested());
12817 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
12819 size_t get_index() const {return type;}
12820 bool is_unknown() const { return type == 2; }
12821 void clear() {type = 0;}
12822 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(ignore); type=1;}
12823 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
12824 template<typename V> bool decode(V& v)
12827 if(!v(ref_nested())) return false;
12828 if(equal(ignore)) { type = 1; return true; }
12829 else { type = 2; return true;}
12833 template<typename V> bool encode(V& v) const
12835 return v(ref_nested());
12839 template<typename V> bool decode(size_t index, V& v)
12844 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
12845 case 2: type = 2; return v(ref_nested());
12846 ref_nested().clear();
12851 template<typename V> bool encode(size_t index, V& v) const
12853 if(index != type) {return false;} return v(ref_nested());
12860 struct Value_t : asn::typefield<true>
12862 ~Value_t() {clear();}
12863 size_t get_index() const {return type;}
12864 E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
12865 E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
12866 bool is_unknown() const { return type == 2; }
12871 case 1: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(); break;
12873 type = 0; ref_nested().clear();
12875 template<typename V> static inline void enumerate(V& v)
12877 v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1);
12881 template<typename V> bool decode(size_t index, V& v)
12886 case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item()); return true;
12887 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
12892 template<typename V> bool encode(size_t index, V& v) const
12894 if(index != type) return false;
12897 case 1: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>()); return true;
12903 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
12904 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
12907 char dummy1[sizeof(E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item)];
12910 asn::variant<sizeof(union_type)> var;
12914 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
12916 size_t get_index() const {return type;}
12917 bool is_unknown() const { return type == 2; }
12918 void clear() {type = 0;}
12919 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(mandatory); type=1;}
12920 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
12921 template<typename V> bool decode(V& v)
12924 if(!v(ref_nested())) return false;
12925 if(equal(mandatory)) { type = 1; return true; }
12926 else { type = 2; return true;}
12930 template<typename V> bool encode(V& v) const
12932 return v(ref_nested());
12936 template<typename V> bool decode(size_t index, V& v)
12941 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
12942 case 2: type = 2; return v(ref_nested());
12943 ref_nested().clear();
12948 template<typename V> bool encode(size_t index, V& v) const
12950 if(index != type) {return false;} return v(ref_nested());
12960 E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF
12961 ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs} }
12964 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>
12966 static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm";}
12967 using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>;
12970 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>
12972 static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList";}
12973 using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>;
12974 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
12978 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12983 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs
12985 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12987 size_t get_index() const {return type;}
12988 bool is_unknown() const { return type == 1; }
12989 void clear() {type = 0;}
12990 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12991 template<typename V> bool decode(V& v)
12994 if(!v(ref_nested())) return false;
12995 { type = 1; return true;}
12999 template<typename V> bool encode(V& v) const
13001 return v(ref_nested());
13005 template<typename V> bool decode(size_t index, V& v)
13010 case 1: type = 1; return v(ref_nested());
13011 ref_nested().clear();
13016 template<typename V> bool encode(size_t index, V& v) const
13018 if(index != type) {return false;} return v(ref_nested());
13025 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13027 size_t get_index() const {return type;}
13028 bool is_unknown() const { return type == 1; }
13029 void clear() {type = 0;}
13030 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13031 template<typename V> bool decode(V& v)
13034 if(!v(ref_nested())) return false;
13035 { type = 1; return true;}
13039 template<typename V> bool encode(V& v) const
13041 return v(ref_nested());
13045 template<typename V> bool decode(size_t index, V& v)
13050 case 1: type = 1; return v(ref_nested());
13051 ref_nested().clear();
13056 template<typename V> bool encode(size_t index, V& v) const
13058 if(index != type) {return false;} return v(ref_nested());
13065 struct Extension_t : asn::typefield<true>
13067 ~Extension_t() {clear();}
13068 size_t get_index() const {return type;}
13069 bool is_unknown() const { return type == 1; }
13072 type = 0; ref_nested().clear();
13074 template<typename V> static inline void enumerate(V& v)
13079 template<typename V> bool decode(size_t index, V& v)
13084 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13089 template<typename V> bool encode(size_t index, V& v) const
13091 if(index != type) return false;
13099 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13101 size_t get_index() const {return type;}
13102 bool is_unknown() const { return type == 1; }
13103 void clear() {type = 0;}
13104 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13105 template<typename V> bool decode(V& v)
13108 if(!v(ref_nested())) return false;
13109 { type = 1; return true;}
13113 template<typename V> bool encode(V& v) const
13115 return v(ref_nested());
13119 template<typename V> bool decode(size_t index, V& v)
13124 case 1: type = 1; return v(ref_nested());
13125 ref_nested().clear();
13130 template<typename V> bool encode(size_t index, V& v) const
13132 if(index != type) {return false;} return v(ref_nested());
13142 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent ::= SEQUENCE {
13143 iE-Extensions ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
13148 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
13150 static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent";}
13151 using parent_t = asn::sequence<1, 0, true, 1>;
13152 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>
13154 static constexpr const char* name() {return "iE_Extensions_t";}
13155 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>;
13156 static constexpr bool optional = true;
13159 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13160 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13161 template<typename V> void decode(V& v)
13166 template<typename V> void encode(V& v) const
13173 iE_Extensions.clear();
13177 iE_Extensions_t iE_Extensions;
13181 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13182 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
13183 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional},
13188 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs
13190 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13192 size_t get_index() const {return type;}
13193 bool is_unknown() const { return type == 3; }
13194 void clear() {type = 0;}
13195 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
13196 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
13197 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13198 template<typename V> bool decode(V& v)
13201 if(!v(ref_nested())) return false;
13202 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
13203 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
13204 else { type = 3; return true;}
13208 template<typename V> bool encode(V& v) const
13210 return v(ref_nested());
13214 template<typename V> bool decode(size_t index, V& v)
13219 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
13220 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
13221 case 3: type = 3; return v(ref_nested());
13222 ref_nested().clear();
13227 template<typename V> bool encode(size_t index, V& v) const
13229 if(index != type) {return false;} return v(ref_nested());
13236 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13238 size_t get_index() const {return type;}
13239 bool is_unknown() const { return type == 3; }
13240 void clear() {type = 0;}
13241 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
13242 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
13243 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13244 template<typename V> bool decode(V& v)
13247 if(!v(ref_nested())) return false;
13248 if(equal(ignore)) { type = 1; return true; }
13249 else if(equal(ignore)) { type = 2; return true; }
13250 else { type = 3; return true;}
13254 template<typename V> bool encode(V& v) const
13256 return v(ref_nested());
13260 template<typename V> bool decode(size_t index, V& v)
13265 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13266 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
13267 case 3: type = 3; return v(ref_nested());
13268 ref_nested().clear();
13273 template<typename V> bool encode(size_t index, V& v) const
13275 if(index != type) {return false;} return v(ref_nested());
13282 struct Extension_t : asn::typefield<true>
13284 ~Extension_t() {clear();}
13285 size_t get_index() const {return type;}
13286 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
13287 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
13288 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
13289 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
13290 bool is_unknown() const { return type == 3; }
13295 case 1: var.destroy<PDCPSnLength>(); break;
13296 case 2: var.destroy<PDCPSnLength>(); break;
13298 type = 0; ref_nested().clear();
13300 template<typename V> static inline void enumerate(V& v)
13302 v.template operator()<PDCPSnLength>(1);
13303 v.template operator()<PDCPSnLength>(2);
13307 template<typename V> bool decode(size_t index, V& v)
13312 case 1: v(select_id_uLpDCPSnLength()); return true;
13313 case 2: v(select_id_dLPDCPSnLength()); return true;
13314 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
13319 template<typename V> bool encode(size_t index, V& v) const
13321 if(index != type) return false;
13324 case 1: v(var.as<PDCPSnLength>()); return true;
13325 case 2: v(var.as<PDCPSnLength>()); return true;
13331 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13332 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13335 char dummy1[sizeof(PDCPSnLength)];
13338 asn::variant<sizeof(union_type)> var;
13342 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13344 size_t get_index() const {return type;}
13345 bool is_unknown() const { return type == 3; }
13346 void clear() {type = 0;}
13347 void select_id_uLpDCPSnLength() { set(optional); type=1;}
13348 void select_id_dLPDCPSnLength() { set(optional); type=2;}
13349 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13350 template<typename V> bool decode(V& v)
13353 if(!v(ref_nested())) return false;
13354 if(equal(optional)) { type = 1; return true; }
13355 else if(equal(optional)) { type = 2; return true; }
13356 else { type = 3; return true;}
13360 template<typename V> bool encode(V& v) const
13362 return v(ref_nested());
13366 template<typename V> bool decode(size_t index, V& v)
13371 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
13372 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
13373 case 3: type = 3; return v(ref_nested());
13374 ref_nested().clear();
13379 template<typename V> bool encode(size_t index, V& v) const
13381 if(index != type) {return false;} return v(ref_nested());
13391 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
13392 secondary-meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
13393 iE-Extensions ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
13398 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
13400 static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent";}
13401 using parent_t = asn::sequence<2, 0, true, 2>;
13402 struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
13404 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
13405 using parent_t = GTPtunnelEndpoint;
13406 static constexpr bool optional = true;
13409 secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
13410 secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
13411 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>
13413 static constexpr const char* name() {return "iE_Extensions_t";}
13414 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>;
13415 static constexpr bool optional = true;
13418 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13419 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13420 template<typename V> void decode(V& v)
13422 v(secondary_meNB_UL_GTP_TEIDatPDCP);
13426 template<typename V> void encode(V& v) const
13428 v(secondary_meNB_UL_GTP_TEIDatPDCP);
13434 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
13435 iE_Extensions.clear();
13439 secondary_meNB_UL_GTP_TEIDatPDCP_t secondary_meNB_UL_GTP_TEIDatPDCP;
13440 iE_Extensions_t iE_Extensions;
13444 E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13449 struct E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs
13451 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13453 size_t get_index() const {return type;}
13454 bool is_unknown() const { return type == 1; }
13455 void clear() {type = 0;}
13456 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13457 template<typename V> bool decode(V& v)
13460 if(!v(ref_nested())) return false;
13461 { type = 1; return true;}
13465 template<typename V> bool encode(V& v) const
13467 return v(ref_nested());
13471 template<typename V> bool decode(size_t index, V& v)
13476 case 1: type = 1; return v(ref_nested());
13477 ref_nested().clear();
13482 template<typename V> bool encode(size_t index, V& v) const
13484 if(index != type) {return false;} return v(ref_nested());
13491 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13493 size_t get_index() const {return type;}
13494 bool is_unknown() const { return type == 1; }
13495 void clear() {type = 0;}
13496 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13497 template<typename V> bool decode(V& v)
13500 if(!v(ref_nested())) return false;
13501 { type = 1; return true;}
13505 template<typename V> bool encode(V& v) const
13507 return v(ref_nested());
13511 template<typename V> bool decode(size_t index, V& v)
13516 case 1: type = 1; return v(ref_nested());
13517 ref_nested().clear();
13522 template<typename V> bool encode(size_t index, V& v) const
13524 if(index != type) {return false;} return v(ref_nested());
13531 struct Extension_t : asn::typefield<true>
13533 ~Extension_t() {clear();}
13534 size_t get_index() const {return type;}
13535 bool is_unknown() const { return type == 1; }
13538 type = 0; ref_nested().clear();
13540 template<typename V> static inline void enumerate(V& v)
13545 template<typename V> bool decode(size_t index, V& v)
13550 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13555 template<typename V> bool encode(size_t index, V& v) const
13557 if(index != type) return false;
13565 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13567 size_t get_index() const {return type;}
13568 bool is_unknown() const { return type == 1; }
13569 void clear() {type = 0;}
13570 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13571 template<typename V> bool decode(V& v)
13574 if(!v(ref_nested())) return false;
13575 { type = 1; return true;}
13579 template<typename V> bool encode(V& v) const
13581 return v(ref_nested());
13585 template<typename V> bool decode(size_t index, V& v)
13590 case 1: type = 1; return v(ref_nested());
13591 ref_nested().clear();
13596 template<typename V> bool encode(size_t index, V& v) const
13598 if(index != type) {return false;} return v(ref_nested());
13608 E-RABs-AdmittedToBeModified-SgNBModConf-Item ::= SEQUENCE {
13610 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
13611 resource-configuration CHOICE {
13612 sgNBPDCPpresent E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent,
13613 sgNBPDCPnotpresent E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent,
13616 iE-Extensions ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs} } OPTIONAL,
13621 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item : asn::sequence<4, 0, true, 1>
13623 static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item";}
13624 using parent_t = asn::sequence<4, 0, true, 1>;
13625 struct e_RAB_ID_t : E_RAB_ID
13627 static constexpr const char* name() {return "e_RAB_ID_t";}
13628 using parent_t = E_RAB_ID;
13631 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
13632 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
13633 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
13635 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
13636 using parent_t = EN_DC_ResourceConfiguration;
13639 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
13640 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
13641 struct resource_configuration_t : asn::choice<2, 0, true>
13643 static constexpr const char* name() {return "resource_configuration_t";}
13644 using parent_t = asn::choice<2, 0, true>;
13645 index_type get_index() const {return index;}
13646 bool is_unknown() const {return index == 3;}
13647 void set_unknown() { set_index(3); }
13648 ~resource_configuration_t() {clear();}
13649 struct sgNBPDCPpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent
13651 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
13652 using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent;
13655 struct sgNBPDCPnotpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent
13657 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
13658 using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent;
13663 switch(get_index())
13665 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
13666 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
13671 template<typename V> bool decode(size_t idx, V& v)
13676 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
13677 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
13682 template<typename V> bool encode(V& v) const
13684 switch(get_index())
13686 case 1: return v(var.as<sgNBPDCPpresent_t>());
13687 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
13691 template<typename V> static inline void enumerate(V& v)
13693 v.template operator()<sgNBPDCPpresent_t>(1);
13694 v.template operator()<sgNBPDCPnotpresent_t>(2);
13697 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
13698 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
13699 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
13700 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
13702 void set_index(index_type i) {index = i; base::set();}
13705 char dummy1[sizeof(sgNBPDCPpresent_t)];
13706 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
13709 asn::variant<sizeof(union_type)> var;
13710 index_type index {0};
13712 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
13713 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
13714 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>
13716 static constexpr const char* name() {return "iE_Extensions_t";}
13717 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>;
13718 static constexpr bool optional = true;
13721 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13722 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13723 template<typename V> void decode(V& v)
13726 v(en_DC_ResourceConfiguration);
13727 v(resource_configuration);
13731 template<typename V> void encode(V& v) const
13734 v(en_DC_ResourceConfiguration);
13735 v(resource_configuration);
13742 en_DC_ResourceConfiguration.clear();
13743 resource_configuration.clear();
13744 iE_Extensions.clear();
13748 e_RAB_ID_t e_RAB_ID;
13749 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
13750 resource_configuration_t resource_configuration;
13751 iE_Extensions_t iE_Extensions;
13755 E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs X2AP-PROTOCOL-IES ::= {
13756 { ID id-E-RABs-AdmittedToBeModified-SgNBModConf-Item CRITICALITY ignore TYPE E-RABs-AdmittedToBeModified-SgNBModConf-Item PRESENCE mandatory },
13761 struct E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs
13763 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
13765 size_t get_index() const {return type;}
13766 bool is_unknown() const { return type == 2; }
13767 void clear() {type = 0;}
13768 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item); type=1;}
13769 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
13770 template<typename V> bool decode(V& v)
13773 if(!v(ref_nested())) return false;
13774 if(equal(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item)) { type = 1; return true; }
13775 else { type = 2; return true;}
13779 template<typename V> bool encode(V& v) const
13781 return v(ref_nested());
13785 template<typename V> bool decode(size_t index, V& v)
13790 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item);} return false;
13791 case 2: type = 2; return v(ref_nested());
13792 ref_nested().clear();
13797 template<typename V> bool encode(size_t index, V& v) const
13799 if(index != type) {return false;} return v(ref_nested());
13806 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
13808 size_t get_index() const {return type;}
13809 bool is_unknown() const { return type == 2; }
13810 void clear() {type = 0;}
13811 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(ignore); type=1;}
13812 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
13813 template<typename V> bool decode(V& v)
13816 if(!v(ref_nested())) return false;
13817 if(equal(ignore)) { type = 1; return true; }
13818 else { type = 2; return true;}
13822 template<typename V> bool encode(V& v) const
13824 return v(ref_nested());
13828 template<typename V> bool decode(size_t index, V& v)
13833 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13834 case 2: type = 2; return v(ref_nested());
13835 ref_nested().clear();
13840 template<typename V> bool encode(size_t index, V& v) const
13842 if(index != type) {return false;} return v(ref_nested());
13849 struct Value_t : asn::typefield<true>
13851 ~Value_t() {clear();}
13852 size_t get_index() const {return type;}
13853 E_RABs_AdmittedToBeModified_SgNBModConf_Item& select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { return set<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
13854 E_RABs_AdmittedToBeModified_SgNBModConf_Item const* get_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() const { return get<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
13855 bool is_unknown() const { return type == 2; }
13860 case 1: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(); break;
13862 type = 0; ref_nested().clear();
13864 template<typename V> static inline void enumerate(V& v)
13866 v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1);
13870 template<typename V> bool decode(size_t index, V& v)
13875 case 1: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item()); return true;
13876 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
13881 template<typename V> bool encode(size_t index, V& v) const
13883 if(index != type) return false;
13886 case 1: v(var.as<E_RABs_AdmittedToBeModified_SgNBModConf_Item>()); return true;
13892 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13893 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13896 char dummy1[sizeof(E_RABs_AdmittedToBeModified_SgNBModConf_Item)];
13899 asn::variant<sizeof(union_type)> var;
13903 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
13905 size_t get_index() const {return type;}
13906 bool is_unknown() const { return type == 2; }
13907 void clear() {type = 0;}
13908 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(mandatory); type=1;}
13909 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
13910 template<typename V> bool decode(V& v)
13913 if(!v(ref_nested())) return false;
13914 if(equal(mandatory)) { type = 1; return true; }
13915 else { type = 2; return true;}
13919 template<typename V> bool encode(V& v) const
13921 return v(ref_nested());
13925 template<typename V> bool decode(size_t index, V& v)
13930 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
13931 case 2: type = 2; return v(ref_nested());
13932 ref_nested().clear();
13937 template<typename V> bool encode(size_t index, V& v) const
13939 if(index != type) {return false;} return v(ref_nested());
13949 E-RABs-AdmittedToBeModified-SgNBModConfList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container
13950 { {E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs} }
13953 struct E_RABs_AdmittedToBeModified_SgNBModConfList_elm : ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>
13955 static constexpr const char* name() {return "E_RABs_AdmittedToBeModified_SgNBModConfList_elm";}
13956 using parent_t = ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>;
13959 struct E_RABs_AdmittedToBeModified_SgNBModConfList : asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>
13961 static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConfList";}
13962 using parent_t = asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>;
13963 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
13967 E-RABs-SubjectToCounterCheckItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13972 struct E_RABs_SubjectToCounterCheckItemExtIEs
13974 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13976 size_t get_index() const {return type;}
13977 bool is_unknown() const { return type == 1; }
13978 void clear() {type = 0;}
13979 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13980 template<typename V> bool decode(V& v)
13983 if(!v(ref_nested())) return false;
13984 { type = 1; return true;}
13988 template<typename V> bool encode(V& v) const
13990 return v(ref_nested());
13994 template<typename V> bool decode(size_t index, V& v)
13999 case 1: type = 1; return v(ref_nested());
14000 ref_nested().clear();
14005 template<typename V> bool encode(size_t index, V& v) const
14007 if(index != type) {return false;} return v(ref_nested());
14014 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14016 size_t get_index() const {return type;}
14017 bool is_unknown() const { return type == 1; }
14018 void clear() {type = 0;}
14019 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14020 template<typename V> bool decode(V& v)
14023 if(!v(ref_nested())) return false;
14024 { type = 1; return true;}
14028 template<typename V> bool encode(V& v) const
14030 return v(ref_nested());
14034 template<typename V> bool decode(size_t index, V& v)
14039 case 1: type = 1; return v(ref_nested());
14040 ref_nested().clear();
14045 template<typename V> bool encode(size_t index, V& v) const
14047 if(index != type) {return false;} return v(ref_nested());
14054 struct Extension_t : asn::typefield<true>
14056 ~Extension_t() {clear();}
14057 size_t get_index() const {return type;}
14058 bool is_unknown() const { return type == 1; }
14061 type = 0; ref_nested().clear();
14063 template<typename V> static inline void enumerate(V& v)
14068 template<typename V> bool decode(size_t index, V& v)
14073 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14078 template<typename V> bool encode(size_t index, V& v) const
14080 if(index != type) return false;
14088 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14090 size_t get_index() const {return type;}
14091 bool is_unknown() const { return type == 1; }
14092 void clear() {type = 0;}
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 { type = 1; return true;}
14102 template<typename V> bool encode(V& v) const
14104 return v(ref_nested());
14108 template<typename V> bool decode(size_t index, V& v)
14113 case 1: type = 1; return v(ref_nested());
14114 ref_nested().clear();
14119 template<typename V> bool encode(size_t index, V& v) const
14121 if(index != type) {return false;} return v(ref_nested());
14131 E-RABs-SubjectToCounterCheckItem ::= SEQUENCE {
14133 uL-Count INTEGER (0..4294967295),
14134 dL-Count INTEGER (0..4294967295),
14135 iE-Extensions ProtocolExtensionContainer { {E-RABs-SubjectToCounterCheckItemExtIEs} } OPTIONAL,
14140 struct E_RABs_SubjectToCounterCheckItem : asn::sequence<4, 0, true, 1>
14142 static constexpr const char* name() {return "E-RABs-SubjectToCounterCheckItem";}
14143 using parent_t = asn::sequence<4, 0, true, 1>;
14144 struct e_RAB_ID_t : E_RAB_ID
14146 static constexpr const char* name() {return "e_RAB_ID_t";}
14147 using parent_t = E_RAB_ID;
14150 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
14151 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
14152 struct uL_Count_t : asn::integer<>
14154 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14155 static constexpr const char* name() {return "uL_Count_t";}
14156 using parent_t = asn::integer<>;
14160 uL_Count_t& ref_uL_Count() {return uL_Count;}
14161 uL_Count_t const& ref_uL_Count() const {return uL_Count;}
14162 struct dL_Count_t : asn::integer<>
14164 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14165 static constexpr const char* name() {return "dL_Count_t";}
14166 using parent_t = asn::integer<>;
14170 dL_Count_t& ref_dL_Count() {return dL_Count;}
14171 dL_Count_t const& ref_dL_Count() const {return dL_Count;}
14172 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>
14174 static constexpr const char* name() {return "iE_Extensions_t";}
14175 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>;
14176 static constexpr bool optional = true;
14179 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14180 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14181 template<typename V> void decode(V& v)
14189 template<typename V> void encode(V& v) const
14202 iE_Extensions.clear();
14206 e_RAB_ID_t e_RAB_ID;
14207 uL_Count_t uL_Count;
14208 dL_Count_t dL_Count;
14209 iE_Extensions_t iE_Extensions;
14213 E-RABs-SubjectToCounterCheckItemIEs X2AP-PROTOCOL-IES ::= {
14214 { ID id-E-RABs-SubjectToCounterCheckItem CRITICALITY ignore TYPE E-RABs-SubjectToCounterCheckItem PRESENCE mandatory},
14219 struct E_RABs_SubjectToCounterCheckItemIEs
14221 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14223 size_t get_index() const {return type;}
14224 bool is_unknown() const { return type == 2; }
14225 void clear() {type = 0;}
14226 void select_id_E_RABs_SubjectToCounterCheckItem() { set(id_E_RABs_SubjectToCounterCheckItem); type=1;}
14227 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14228 template<typename V> bool decode(V& v)
14231 if(!v(ref_nested())) return false;
14232 if(equal(id_E_RABs_SubjectToCounterCheckItem)) { type = 1; return true; }
14233 else { type = 2; return true;}
14237 template<typename V> bool encode(V& v) const
14239 return v(ref_nested());
14243 template<typename V> bool decode(size_t index, V& v)
14248 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToCounterCheckItem);} return false;
14249 case 2: type = 2; return v(ref_nested());
14250 ref_nested().clear();
14255 template<typename V> bool encode(size_t index, V& v) const
14257 if(index != type) {return false;} return v(ref_nested());
14264 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14266 size_t get_index() const {return type;}
14267 bool is_unknown() const { return type == 2; }
14268 void clear() {type = 0;}
14269 void select_id_E_RABs_SubjectToCounterCheckItem() { set(ignore); type=1;}
14270 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14271 template<typename V> bool decode(V& v)
14274 if(!v(ref_nested())) return false;
14275 if(equal(ignore)) { type = 1; return true; }
14276 else { type = 2; return true;}
14280 template<typename V> bool encode(V& v) const
14282 return v(ref_nested());
14286 template<typename V> bool decode(size_t index, V& v)
14291 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14292 case 2: type = 2; return v(ref_nested());
14293 ref_nested().clear();
14298 template<typename V> bool encode(size_t index, V& v) const
14300 if(index != type) {return false;} return v(ref_nested());
14307 struct Value_t : asn::typefield<true>
14309 ~Value_t() {clear();}
14310 size_t get_index() const {return type;}
14311 E_RABs_SubjectToCounterCheckItem& select_id_E_RABs_SubjectToCounterCheckItem() { return set<E_RABs_SubjectToCounterCheckItem>(1); }
14312 E_RABs_SubjectToCounterCheckItem const* get_id_E_RABs_SubjectToCounterCheckItem() const { return get<E_RABs_SubjectToCounterCheckItem>(1); }
14313 bool is_unknown() const { return type == 2; }
14318 case 1: var.destroy<E_RABs_SubjectToCounterCheckItem>(); break;
14320 type = 0; ref_nested().clear();
14322 template<typename V> static inline void enumerate(V& v)
14324 v.template operator()<E_RABs_SubjectToCounterCheckItem>(1);
14328 template<typename V> bool decode(size_t index, V& v)
14333 case 1: v(select_id_E_RABs_SubjectToCounterCheckItem()); return true;
14334 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14339 template<typename V> bool encode(size_t index, V& v) const
14341 if(index != type) return false;
14344 case 1: v(var.as<E_RABs_SubjectToCounterCheckItem>()); return true;
14350 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14351 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14354 char dummy1[sizeof(E_RABs_SubjectToCounterCheckItem)];
14357 asn::variant<sizeof(union_type)> var;
14361 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14363 size_t get_index() const {return type;}
14364 bool is_unknown() const { return type == 2; }
14365 void clear() {type = 0;}
14366 void select_id_E_RABs_SubjectToCounterCheckItem() { set(mandatory); type=1;}
14367 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14368 template<typename V> bool decode(V& v)
14371 if(!v(ref_nested())) return false;
14372 if(equal(mandatory)) { type = 1; return true; }
14373 else { type = 2; return true;}
14377 template<typename V> bool encode(V& v) const
14379 return v(ref_nested());
14383 template<typename V> bool decode(size_t index, V& v)
14388 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14389 case 2: type = 2; return v(ref_nested());
14390 ref_nested().clear();
14395 template<typename V> bool encode(size_t index, V& v) const
14397 if(index != type) {return false;} return v(ref_nested());
14407 E-RABs-SubjectToCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToCounterCheckItemIEs} }
14410 struct E_RABs_SubjectToCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>
14412 static constexpr const char* name() {return "E_RABs_SubjectToCounterCheck_List_elm";}
14413 using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>;
14416 struct E_RABs_SubjectToCounterCheck_List : asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>
14418 static constexpr const char* name() {return "E-RABs-SubjectToCounterCheck-List";}
14419 using parent_t = asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>;
14420 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
14424 E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14429 struct E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs
14431 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14433 size_t get_index() const {return type;}
14434 bool is_unknown() const { return type == 1; }
14435 void clear() {type = 0;}
14436 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14437 template<typename V> bool decode(V& v)
14440 if(!v(ref_nested())) return false;
14441 { type = 1; return true;}
14445 template<typename V> bool encode(V& v) const
14447 return v(ref_nested());
14451 template<typename V> bool decode(size_t index, V& v)
14456 case 1: type = 1; return v(ref_nested());
14457 ref_nested().clear();
14462 template<typename V> bool encode(size_t index, V& v) const
14464 if(index != type) {return false;} return v(ref_nested());
14471 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14473 size_t get_index() const {return type;}
14474 bool is_unknown() const { return type == 1; }
14475 void clear() {type = 0;}
14476 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14477 template<typename V> bool decode(V& v)
14480 if(!v(ref_nested())) return false;
14481 { type = 1; return true;}
14485 template<typename V> bool encode(V& v) const
14487 return v(ref_nested());
14491 template<typename V> bool decode(size_t index, V& v)
14496 case 1: type = 1; return v(ref_nested());
14497 ref_nested().clear();
14502 template<typename V> bool encode(size_t index, V& v) const
14504 if(index != type) {return false;} return v(ref_nested());
14511 struct Extension_t : asn::typefield<true>
14513 ~Extension_t() {clear();}
14514 size_t get_index() const {return type;}
14515 bool is_unknown() const { return type == 1; }
14518 type = 0; ref_nested().clear();
14520 template<typename V> static inline void enumerate(V& v)
14525 template<typename V> bool decode(size_t index, V& v)
14530 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14535 template<typename V> bool encode(size_t index, V& v) const
14537 if(index != type) return false;
14545 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14547 size_t get_index() const {return type;}
14548 bool is_unknown() const { return type == 1; }
14549 void clear() {type = 0;}
14550 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14551 template<typename V> bool decode(V& v)
14554 if(!v(ref_nested())) return false;
14555 { type = 1; return true;}
14559 template<typename V> bool encode(V& v) const
14561 return v(ref_nested());
14565 template<typename V> bool decode(size_t index, V& v)
14570 case 1: type = 1; return v(ref_nested());
14571 ref_nested().clear();
14576 template<typename V> bool encode(size_t index, V& v) const
14578 if(index != type) {return false;} return v(ref_nested());
14588 E-RABs-SubjectToSgNBCounterCheck-Item ::= SEQUENCE {
14590 uL-Count INTEGER (0..4294967295),
14591 dL-Count INTEGER (0..4294967295),
14592 iE-Extensions ProtocolExtensionContainer { {E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs} } OPTIONAL,
14597 struct E_RABs_SubjectToSgNBCounterCheck_Item : asn::sequence<4, 0, true, 1>
14599 static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-Item";}
14600 using parent_t = asn::sequence<4, 0, true, 1>;
14601 struct e_RAB_ID_t : E_RAB_ID
14603 static constexpr const char* name() {return "e_RAB_ID_t";}
14604 using parent_t = E_RAB_ID;
14607 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
14608 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
14609 struct uL_Count_t : asn::integer<>
14611 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14612 static constexpr const char* name() {return "uL_Count_t";}
14613 using parent_t = asn::integer<>;
14617 uL_Count_t& ref_uL_Count() {return uL_Count;}
14618 uL_Count_t const& ref_uL_Count() const {return uL_Count;}
14619 struct dL_Count_t : asn::integer<>
14621 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14622 static constexpr const char* name() {return "dL_Count_t";}
14623 using parent_t = asn::integer<>;
14627 dL_Count_t& ref_dL_Count() {return dL_Count;}
14628 dL_Count_t const& ref_dL_Count() const {return dL_Count;}
14629 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>
14631 static constexpr const char* name() {return "iE_Extensions_t";}
14632 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>;
14633 static constexpr bool optional = true;
14636 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14637 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14638 template<typename V> void decode(V& v)
14646 template<typename V> void encode(V& v) const
14659 iE_Extensions.clear();
14663 e_RAB_ID_t e_RAB_ID;
14664 uL_Count_t uL_Count;
14665 dL_Count_t dL_Count;
14666 iE_Extensions_t iE_Extensions;
14670 E-RABs-SubjectToSgNBCounterCheck-ItemIEs X2AP-PROTOCOL-IES ::= {
14671 { ID id-E-RABs-SubjectToSgNBCounterCheck-Item CRITICALITY ignore TYPE E-RABs-SubjectToSgNBCounterCheck-Item PRESENCE mandatory},
14676 struct E_RABs_SubjectToSgNBCounterCheck_ItemIEs
14678 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14680 size_t get_index() const {return type;}
14681 bool is_unknown() const { return type == 2; }
14682 void clear() {type = 0;}
14683 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(id_E_RABs_SubjectToSgNBCounterCheck_Item); type=1;}
14684 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14685 template<typename V> bool decode(V& v)
14688 if(!v(ref_nested())) return false;
14689 if(equal(id_E_RABs_SubjectToSgNBCounterCheck_Item)) { type = 1; return true; }
14690 else { type = 2; return true;}
14694 template<typename V> bool encode(V& v) const
14696 return v(ref_nested());
14700 template<typename V> bool decode(size_t index, V& v)
14705 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToSgNBCounterCheck_Item);} return false;
14706 case 2: type = 2; return v(ref_nested());
14707 ref_nested().clear();
14712 template<typename V> bool encode(size_t index, V& v) const
14714 if(index != type) {return false;} return v(ref_nested());
14721 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14723 size_t get_index() const {return type;}
14724 bool is_unknown() const { return type == 2; }
14725 void clear() {type = 0;}
14726 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(ignore); type=1;}
14727 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14728 template<typename V> bool decode(V& v)
14731 if(!v(ref_nested())) return false;
14732 if(equal(ignore)) { type = 1; return true; }
14733 else { type = 2; return true;}
14737 template<typename V> bool encode(V& v) const
14739 return v(ref_nested());
14743 template<typename V> bool decode(size_t index, V& v)
14748 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14749 case 2: type = 2; return v(ref_nested());
14750 ref_nested().clear();
14755 template<typename V> bool encode(size_t index, V& v) const
14757 if(index != type) {return false;} return v(ref_nested());
14764 struct Value_t : asn::typefield<true>
14766 ~Value_t() {clear();}
14767 size_t get_index() const {return type;}
14768 E_RABs_SubjectToSgNBCounterCheck_Item& select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { return set<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
14769 E_RABs_SubjectToSgNBCounterCheck_Item const* get_id_E_RABs_SubjectToSgNBCounterCheck_Item() const { return get<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
14770 bool is_unknown() const { return type == 2; }
14775 case 1: var.destroy<E_RABs_SubjectToSgNBCounterCheck_Item>(); break;
14777 type = 0; ref_nested().clear();
14779 template<typename V> static inline void enumerate(V& v)
14781 v.template operator()<E_RABs_SubjectToSgNBCounterCheck_Item>(1);
14785 template<typename V> bool decode(size_t index, V& v)
14790 case 1: v(select_id_E_RABs_SubjectToSgNBCounterCheck_Item()); return true;
14791 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14796 template<typename V> bool encode(size_t index, V& v) const
14798 if(index != type) return false;
14801 case 1: v(var.as<E_RABs_SubjectToSgNBCounterCheck_Item>()); return true;
14807 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14808 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14811 char dummy1[sizeof(E_RABs_SubjectToSgNBCounterCheck_Item)];
14814 asn::variant<sizeof(union_type)> var;
14818 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14820 size_t get_index() const {return type;}
14821 bool is_unknown() const { return type == 2; }
14822 void clear() {type = 0;}
14823 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(mandatory); type=1;}
14824 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14825 template<typename V> bool decode(V& v)
14828 if(!v(ref_nested())) return false;
14829 if(equal(mandatory)) { type = 1; return true; }
14830 else { type = 2; return true;}
14834 template<typename V> bool encode(V& v) const
14836 return v(ref_nested());
14840 template<typename V> bool decode(size_t index, V& v)
14845 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14846 case 2: type = 2; return v(ref_nested());
14847 ref_nested().clear();
14852 template<typename V> bool encode(size_t index, V& v) const
14854 if(index != type) {return false;} return v(ref_nested());
14864 E-RABs-SubjectToSgNBCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToSgNBCounterCheck-ItemIEs} }
14867 struct E_RABs_SubjectToSgNBCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>
14869 static constexpr const char* name() {return "E_RABs_SubjectToSgNBCounterCheck_List_elm";}
14870 using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>;
14873 struct E_RABs_SubjectToSgNBCounterCheck_List : asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>
14875 static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-List";}
14876 using parent_t = asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>;
14877 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
14881 E-RABs-SubjectToStatusTransfer-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14882 { ID id-ReceiveStatusOfULPDCPSDUsExtended CRITICALITY ignore EXTENSION ReceiveStatusOfULPDCPSDUsExtended PRESENCE optional}|
14883 { ID id-ULCOUNTValueExtended CRITICALITY ignore EXTENSION COUNTValueExtended PRESENCE optional}|
14884 { ID id-DLCOUNTValueExtended CRITICALITY ignore EXTENSION COUNTValueExtended PRESENCE optional}|
14885 { ID id-ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 CRITICALITY ignore EXTENSION ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 PRESENCE optional}|
14886 { ID id-ULCOUNTValuePDCP-SNlength18 CRITICALITY ignore EXTENSION COUNTvaluePDCP-SNlength18 PRESENCE optional}|
14887 { ID id-DLCOUNTValuePDCP-SNlength18 CRITICALITY ignore EXTENSION COUNTvaluePDCP-SNlength18 PRESENCE optional},
14892 struct E_RABs_SubjectToStatusTransfer_ItemExtIEs
14894 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14896 size_t get_index() const {return type;}
14897 bool is_unknown() const { return type == 7; }
14898 void clear() {type = 0;}
14899 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(id_ReceiveStatusOfULPDCPSDUsExtended); type=1;}
14900 void select_id_ULCOUNTValueExtended() { set(id_ULCOUNTValueExtended); type=2;}
14901 void select_id_DLCOUNTValueExtended() { set(id_DLCOUNTValueExtended); type=3;}
14902 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18); type=4;}
14903 void select_id_ULCOUNTValuePDCP_SNlength18() { set(id_ULCOUNTValuePDCP_SNlength18); type=5;}
14904 void select_id_DLCOUNTValuePDCP_SNlength18() { set(id_DLCOUNTValuePDCP_SNlength18); type=6;}
14905 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14906 template<typename V> bool decode(V& v)
14909 if(!v(ref_nested())) return false;
14910 if(equal(id_ReceiveStatusOfULPDCPSDUsExtended)) { type = 1; return true; }
14911 else if(equal(id_ULCOUNTValueExtended)) { type = 2; return true; }
14912 else if(equal(id_DLCOUNTValueExtended)) { type = 3; return true; }
14913 else if(equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)) { type = 4; return true; }
14914 else if(equal(id_ULCOUNTValuePDCP_SNlength18)) { type = 5; return true; }
14915 else if(equal(id_DLCOUNTValuePDCP_SNlength18)) { type = 6; return true; }
14916 else { type = 7; return true;}
14920 template<typename V> bool encode(V& v) const
14922 return v(ref_nested());
14926 template<typename V> bool decode(size_t index, V& v)
14931 case 1: type = 1; if(v(ref_nested())) { return equal(id_ReceiveStatusOfULPDCPSDUsExtended);} return false;
14932 case 2: type = 2; if(v(ref_nested())) { return equal(id_ULCOUNTValueExtended);} return false;
14933 case 3: type = 3; if(v(ref_nested())) { return equal(id_DLCOUNTValueExtended);} return false;
14934 case 4: type = 4; if(v(ref_nested())) { return equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18);} return false;
14935 case 5: type = 5; if(v(ref_nested())) { return equal(id_ULCOUNTValuePDCP_SNlength18);} return false;
14936 case 6: type = 6; if(v(ref_nested())) { return equal(id_DLCOUNTValuePDCP_SNlength18);} return false;
14937 case 7: type = 7; return v(ref_nested());
14938 ref_nested().clear();
14943 template<typename V> bool encode(size_t index, V& v) const
14945 if(index != type) {return false;} return v(ref_nested());
14952 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14954 size_t get_index() const {return type;}
14955 bool is_unknown() const { return type == 7; }
14956 void clear() {type = 0;}
14957 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(ignore); type=1;}
14958 void select_id_ULCOUNTValueExtended() { set(ignore); type=2;}
14959 void select_id_DLCOUNTValueExtended() { set(ignore); type=3;}
14960 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(ignore); type=4;}
14961 void select_id_ULCOUNTValuePDCP_SNlength18() { set(ignore); type=5;}
14962 void select_id_DLCOUNTValuePDCP_SNlength18() { set(ignore); type=6;}
14963 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14964 template<typename V> bool decode(V& v)
14967 if(!v(ref_nested())) return false;
14968 if(equal(ignore)) { type = 1; return true; }
14969 else if(equal(ignore)) { type = 2; return true; }
14970 else if(equal(ignore)) { type = 3; return true; }
14971 else if(equal(ignore)) { type = 4; return true; }
14972 else if(equal(ignore)) { type = 5; return true; }
14973 else if(equal(ignore)) { type = 6; return true; }
14974 else { type = 7; return true;}
14978 template<typename V> bool encode(V& v) const
14980 return v(ref_nested());
14984 template<typename V> bool decode(size_t index, V& v)
14989 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14990 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
14991 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
14992 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
14993 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
14994 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
14995 case 7: type = 7; return v(ref_nested());
14996 ref_nested().clear();
15001 template<typename V> bool encode(size_t index, V& v) const
15003 if(index != type) {return false;} return v(ref_nested());
15010 struct Extension_t : asn::typefield<true>
15012 ~Extension_t() {clear();}
15013 size_t get_index() const {return type;}
15014 ReceiveStatusOfULPDCPSDUsExtended& select_id_ReceiveStatusOfULPDCPSDUsExtended() { return set<ReceiveStatusOfULPDCPSDUsExtended>(1); }
15015 ReceiveStatusOfULPDCPSDUsExtended const* get_id_ReceiveStatusOfULPDCPSDUsExtended() const { return get<ReceiveStatusOfULPDCPSDUsExtended>(1); }
15016 COUNTValueExtended& select_id_ULCOUNTValueExtended() { return set<COUNTValueExtended>(2); }
15017 COUNTValueExtended const* get_id_ULCOUNTValueExtended() const { return get<COUNTValueExtended>(2); }
15018 COUNTValueExtended& select_id_DLCOUNTValueExtended() { return set<COUNTValueExtended>(3); }
15019 COUNTValueExtended const* get_id_DLCOUNTValueExtended() const { return get<COUNTValueExtended>(3); }
15020 ReceiveStatusOfULPDCPSDUsPDCP_SNlength18& select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { return set<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
15021 ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 const* get_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() const { return get<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
15022 COUNTvaluePDCP_SNlength18& select_id_ULCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(5); }
15023 COUNTvaluePDCP_SNlength18 const* get_id_ULCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(5); }
15024 COUNTvaluePDCP_SNlength18& select_id_DLCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(6); }
15025 COUNTvaluePDCP_SNlength18 const* get_id_DLCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(6); }
15026 bool is_unknown() const { return type == 7; }
15031 case 1: var.destroy<ReceiveStatusOfULPDCPSDUsExtended>(); break;
15032 case 2: var.destroy<COUNTValueExtended>(); break;
15033 case 3: var.destroy<COUNTValueExtended>(); break;
15034 case 4: var.destroy<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(); break;
15035 case 5: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
15036 case 6: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
15038 type = 0; ref_nested().clear();
15040 template<typename V> static inline void enumerate(V& v)
15042 v.template operator()<ReceiveStatusOfULPDCPSDUsExtended>(1);
15043 v.template operator()<COUNTValueExtended>(2);
15044 v.template operator()<COUNTValueExtended>(3);
15045 v.template operator()<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4);
15046 v.template operator()<COUNTvaluePDCP_SNlength18>(5);
15047 v.template operator()<COUNTvaluePDCP_SNlength18>(6);
15051 template<typename V> bool decode(size_t index, V& v)
15056 case 1: v(select_id_ReceiveStatusOfULPDCPSDUsExtended()); return true;
15057 case 2: v(select_id_ULCOUNTValueExtended()); return true;
15058 case 3: v(select_id_DLCOUNTValueExtended()); return true;
15059 case 4: v(select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18()); return true;
15060 case 5: v(select_id_ULCOUNTValuePDCP_SNlength18()); return true;
15061 case 6: v(select_id_DLCOUNTValuePDCP_SNlength18()); return true;
15062 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
15067 template<typename V> bool encode(size_t index, V& v) const
15069 if(index != type) return false;
15072 case 1: v(var.as<ReceiveStatusOfULPDCPSDUsExtended>()); return true;
15073 case 2: v(var.as<COUNTValueExtended>()); return true;
15074 case 3: v(var.as<COUNTValueExtended>()); return true;
15075 case 4: v(var.as<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>()); return true;
15076 case 5: v(var.as<COUNTvaluePDCP_SNlength18>()); return true;
15077 case 6: v(var.as<COUNTvaluePDCP_SNlength18>()); return true;
15083 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15084 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15087 char dummy1[sizeof(COUNTValueExtended)];
15088 char dummy2[sizeof(COUNTvaluePDCP_SNlength18)];
15089 char dummy3[sizeof(ReceiveStatusOfULPDCPSDUsExtended)];
15090 char dummy4[sizeof(ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)];
15093 asn::variant<sizeof(union_type)> var;
15097 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15099 size_t get_index() const {return type;}
15100 bool is_unknown() const { return type == 7; }
15101 void clear() {type = 0;}
15102 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(optional); type=1;}
15103 void select_id_ULCOUNTValueExtended() { set(optional); type=2;}
15104 void select_id_DLCOUNTValueExtended() { set(optional); type=3;}
15105 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(optional); type=4;}
15106 void select_id_ULCOUNTValuePDCP_SNlength18() { set(optional); type=5;}
15107 void select_id_DLCOUNTValuePDCP_SNlength18() { set(optional); type=6;}
15108 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15109 template<typename V> bool decode(V& v)
15112 if(!v(ref_nested())) return false;
15113 if(equal(optional)) { type = 1; return true; }
15114 else if(equal(optional)) { type = 2; return true; }
15115 else if(equal(optional)) { type = 3; return true; }
15116 else if(equal(optional)) { type = 4; return true; }
15117 else if(equal(optional)) { type = 5; return true; }
15118 else if(equal(optional)) { type = 6; return true; }
15119 else { type = 7; return true;}
15123 template<typename V> bool encode(V& v) const
15125 return v(ref_nested());
15129 template<typename V> bool decode(size_t index, V& v)
15134 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15135 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15136 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
15137 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
15138 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
15139 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
15140 case 7: type = 7; return v(ref_nested());
15141 ref_nested().clear();
15146 template<typename V> bool encode(size_t index, V& v) const
15148 if(index != type) {return false;} return v(ref_nested());
15158 E-RABs-SubjectToStatusTransfer-Item ::= SEQUENCE {
15161 receiveStatusofULPDCPSDUs ReceiveStatusofULPDCPSDUs OPTIONAL,
15162 uL-COUNTvalue COUNTvalue,
15163 dL-COUNTvalue COUNTvalue,
15164 iE-Extensions ProtocolExtensionContainer { {E-RABs-SubjectToStatusTransfer-ItemExtIEs} } OPTIONAL,
15169 struct E_RABs_SubjectToStatusTransfer_Item : asn::sequence<5, 0, true, 2>
15171 static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-Item";}
15172 using parent_t = asn::sequence<5, 0, true, 2>;
15173 struct e_RAB_ID_t : E_RAB_ID
15175 static constexpr const char* name() {return "e_RAB_ID_t";}
15176 using parent_t = E_RAB_ID;
15179 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15180 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15181 struct receiveStatusofULPDCPSDUs_t : ReceiveStatusofULPDCPSDUs
15183 static constexpr const char* name() {return "receiveStatusofULPDCPSDUs_t";}
15184 using parent_t = ReceiveStatusofULPDCPSDUs;
15185 static constexpr bool optional = true;
15188 receiveStatusofULPDCPSDUs_t& set_receiveStatusofULPDCPSDUs() { receiveStatusofULPDCPSDUs.setpresent(true); return receiveStatusofULPDCPSDUs;}
15189 receiveStatusofULPDCPSDUs_t const* get_receiveStatusofULPDCPSDUs() const {return receiveStatusofULPDCPSDUs.is_valid() ? &receiveStatusofULPDCPSDUs : nullptr;}
15190 struct uL_COUNTvalue_t : COUNTvalue
15192 static constexpr const char* name() {return "uL_COUNTvalue_t";}
15193 using parent_t = COUNTvalue;
15196 uL_COUNTvalue_t& ref_uL_COUNTvalue() {return uL_COUNTvalue;}
15197 uL_COUNTvalue_t const& ref_uL_COUNTvalue() const {return uL_COUNTvalue;}
15198 struct dL_COUNTvalue_t : COUNTvalue
15200 static constexpr const char* name() {return "dL_COUNTvalue_t";}
15201 using parent_t = COUNTvalue;
15204 dL_COUNTvalue_t& ref_dL_COUNTvalue() {return dL_COUNTvalue;}
15205 dL_COUNTvalue_t const& ref_dL_COUNTvalue() const {return dL_COUNTvalue;}
15206 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>
15208 static constexpr const char* name() {return "iE_Extensions_t";}
15209 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>;
15210 static constexpr bool optional = true;
15213 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15214 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15215 template<typename V> void decode(V& v)
15218 v(receiveStatusofULPDCPSDUs);
15224 template<typename V> void encode(V& v) const
15227 v(receiveStatusofULPDCPSDUs);
15236 receiveStatusofULPDCPSDUs.clear();
15237 uL_COUNTvalue.clear();
15238 dL_COUNTvalue.clear();
15239 iE_Extensions.clear();
15243 e_RAB_ID_t e_RAB_ID;
15244 receiveStatusofULPDCPSDUs_t receiveStatusofULPDCPSDUs;
15245 uL_COUNTvalue_t uL_COUNTvalue;
15246 dL_COUNTvalue_t dL_COUNTvalue;
15247 iE_Extensions_t iE_Extensions;
15251 E-RABs-SubjectToStatusTransfer-ItemIEs X2AP-PROTOCOL-IES ::= {
15252 { ID id-E-RABs-SubjectToStatusTransfer-Item CRITICALITY ignore TYPE E-RABs-SubjectToStatusTransfer-Item PRESENCE mandatory }
15256 struct E_RABs_SubjectToStatusTransfer_ItemIEs
15258 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
15260 size_t get_index() const {return type;}
15261 void clear() {type = 0;}
15262 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(id_E_RABs_SubjectToStatusTransfer_Item); type=1;}
15263 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
15264 template<typename V> bool decode(V& v)
15267 if(!v(ref_nested())) return false;
15268 if(equal(id_E_RABs_SubjectToStatusTransfer_Item)) { type = 1; return true; }
15272 template<typename V> bool encode(V& v) const
15274 return v(ref_nested());
15278 template<typename V> bool decode(size_t index, V& v)
15283 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToStatusTransfer_Item);} return false;
15284 ref_nested().clear();
15289 template<typename V> bool encode(size_t index, V& v) const
15291 if(index != type) {return false;} return v(ref_nested());
15298 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
15300 size_t get_index() const {return type;}
15301 void clear() {type = 0;}
15302 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(ignore); type=1;}
15303 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
15304 template<typename V> bool decode(V& v)
15307 if(!v(ref_nested())) return false;
15308 if(equal(ignore)) { type = 1; return true; }
15312 template<typename V> bool encode(V& v) const
15314 return v(ref_nested());
15318 template<typename V> bool decode(size_t index, V& v)
15323 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
15324 ref_nested().clear();
15329 template<typename V> bool encode(size_t index, V& v) const
15331 if(index != type) {return false;} return v(ref_nested());
15338 struct Value_t : asn::typefield<false>
15340 ~Value_t() {clear();}
15341 size_t get_index() const {return type;}
15342 E_RABs_SubjectToStatusTransfer_Item& select_id_E_RABs_SubjectToStatusTransfer_Item() { return set<E_RABs_SubjectToStatusTransfer_Item>(1); }
15343 E_RABs_SubjectToStatusTransfer_Item const* get_id_E_RABs_SubjectToStatusTransfer_Item() const { return get<E_RABs_SubjectToStatusTransfer_Item>(1); }
15348 case 1: var.destroy<E_RABs_SubjectToStatusTransfer_Item>(); break;
15350 type = 0; ref_nested().clear();
15352 template<typename V> static inline void enumerate(V& v)
15354 v.template operator()<E_RABs_SubjectToStatusTransfer_Item>(1);
15358 template<typename V> bool decode(size_t index, V& v)
15363 case 1: v(select_id_E_RABs_SubjectToStatusTransfer_Item()); return true;
15368 template<typename V> bool encode(size_t index, V& v) const
15370 if(index != type) return false;
15373 case 1: v(var.as<E_RABs_SubjectToStatusTransfer_Item>()); return true;
15379 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15380 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15383 char dummy1[sizeof(E_RABs_SubjectToStatusTransfer_Item)];
15386 asn::variant<sizeof(union_type)> var;
15390 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
15392 size_t get_index() const {return type;}
15393 void clear() {type = 0;}
15394 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(mandatory); type=1;}
15395 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
15396 template<typename V> bool decode(V& v)
15399 if(!v(ref_nested())) return false;
15400 if(equal(mandatory)) { type = 1; return true; }
15404 template<typename V> bool encode(V& v) const
15406 return v(ref_nested());
15410 template<typename V> bool decode(size_t index, V& v)
15415 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
15416 ref_nested().clear();
15421 template<typename V> bool encode(size_t index, V& v) const
15423 if(index != type) {return false;} return v(ref_nested());
15433 E-RABs-SubjectToStatusTransfer-List ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToStatusTransfer-ItemIEs} }
15436 struct E_RABs_SubjectToStatusTransfer_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>
15438 static constexpr const char* name() {return "E_RABs_SubjectToStatusTransfer_List_elm";}
15439 using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>;
15442 struct E_RABs_SubjectToStatusTransfer_List : asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>
15444 static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-List";}
15445 using parent_t = asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>;
15446 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
15450 E-RABs-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15451 { ID id-Correlation-ID CRITICALITY ignore EXTENSION Correlation-ID PRESENCE optional}|
15452 { ID id-SIPTO-Correlation-ID CRITICALITY ignore EXTENSION Correlation-ID PRESENCE optional},
15457 struct E_RABs_ToBeAdded_Item_SCG_BearerExtIEs
15459 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15461 size_t get_index() const {return type;}
15462 bool is_unknown() const { return type == 3; }
15463 void clear() {type = 0;}
15464 void select_id_Correlation_ID() { set(id_Correlation_ID); type=1;}
15465 void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); type=2;}
15466 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15467 template<typename V> bool decode(V& v)
15470 if(!v(ref_nested())) return false;
15471 if(equal(id_Correlation_ID)) { type = 1; return true; }
15472 else if(equal(id_SIPTO_Correlation_ID)) { type = 2; return true; }
15473 else { type = 3; return true;}
15477 template<typename V> bool encode(V& v) const
15479 return v(ref_nested());
15483 template<typename V> bool decode(size_t index, V& v)
15488 case 1: type = 1; if(v(ref_nested())) { return equal(id_Correlation_ID);} return false;
15489 case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} return false;
15490 case 3: type = 3; return v(ref_nested());
15491 ref_nested().clear();
15496 template<typename V> bool encode(size_t index, V& v) const
15498 if(index != type) {return false;} return v(ref_nested());
15505 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15507 size_t get_index() const {return type;}
15508 bool is_unknown() const { return type == 3; }
15509 void clear() {type = 0;}
15510 void select_id_Correlation_ID() { set(ignore); type=1;}
15511 void select_id_SIPTO_Correlation_ID() { set(ignore); type=2;}
15512 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15513 template<typename V> bool decode(V& v)
15516 if(!v(ref_nested())) return false;
15517 if(equal(ignore)) { type = 1; return true; }
15518 else if(equal(ignore)) { type = 2; return true; }
15519 else { type = 3; return true;}
15523 template<typename V> bool encode(V& v) const
15525 return v(ref_nested());
15529 template<typename V> bool decode(size_t index, V& v)
15534 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
15535 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
15536 case 3: type = 3; return v(ref_nested());
15537 ref_nested().clear();
15542 template<typename V> bool encode(size_t index, V& v) const
15544 if(index != type) {return false;} return v(ref_nested());
15551 struct Extension_t : asn::typefield<true>
15553 ~Extension_t() {clear();}
15554 size_t get_index() const {return type;}
15555 Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
15556 Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
15557 Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
15558 Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
15559 bool is_unknown() const { return type == 3; }
15564 case 1: var.destroy<Correlation_ID>(); break;
15565 case 2: var.destroy<Correlation_ID>(); break;
15567 type = 0; ref_nested().clear();
15569 template<typename V> static inline void enumerate(V& v)
15571 v.template operator()<Correlation_ID>(1);
15572 v.template operator()<Correlation_ID>(2);
15576 template<typename V> bool decode(size_t index, V& v)
15581 case 1: v(select_id_Correlation_ID()); return true;
15582 case 2: v(select_id_SIPTO_Correlation_ID()); return true;
15583 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
15588 template<typename V> bool encode(size_t index, V& v) const
15590 if(index != type) return false;
15593 case 1: v(var.as<Correlation_ID>()); return true;
15594 case 2: v(var.as<Correlation_ID>()); return true;
15600 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15601 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15604 char dummy1[sizeof(Correlation_ID)];
15607 asn::variant<sizeof(union_type)> var;
15611 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15613 size_t get_index() const {return type;}
15614 bool is_unknown() const { return type == 3; }
15615 void clear() {type = 0;}
15616 void select_id_Correlation_ID() { set(optional); type=1;}
15617 void select_id_SIPTO_Correlation_ID() { set(optional); type=2;}
15618 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15619 template<typename V> bool decode(V& v)
15622 if(!v(ref_nested())) return false;
15623 if(equal(optional)) { type = 1; return true; }
15624 else if(equal(optional)) { type = 2; return true; }
15625 else { type = 3; return true;}
15629 template<typename V> bool encode(V& v) const
15631 return v(ref_nested());
15635 template<typename V> bool decode(size_t index, V& v)
15640 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15641 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15642 case 3: type = 3; return v(ref_nested());
15643 ref_nested().clear();
15648 template<typename V> bool encode(size_t index, V& v) const
15650 if(index != type) {return false;} return v(ref_nested());
15660 E-RABs-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
15662 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
15663 dL-Forwarding DL-Forwarding OPTIONAL,
15664 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint,
15665 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-SCG-BearerExtIEs} } OPTIONAL,
15670 struct E_RABs_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 2>
15672 static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-SCG-Bearer";}
15673 using parent_t = asn::sequence<5, 0, true, 2>;
15674 struct e_RAB_ID_t : E_RAB_ID
15676 static constexpr const char* name() {return "e_RAB_ID_t";}
15677 using parent_t = E_RAB_ID;
15680 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15681 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15682 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
15684 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
15685 using parent_t = E_RAB_Level_QoS_Parameters;
15688 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
15689 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
15690 struct dL_Forwarding_t : DL_Forwarding
15692 static constexpr const char* name() {return "dL_Forwarding_t";}
15693 using parent_t = DL_Forwarding;
15694 static constexpr bool optional = true;
15697 dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
15698 dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
15699 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
15701 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
15702 using parent_t = GTPtunnelEndpoint;
15705 s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
15706 s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
15707 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>
15709 static constexpr const char* name() {return "iE_Extensions_t";}
15710 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>;
15711 static constexpr bool optional = true;
15714 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15715 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15716 template<typename V> void decode(V& v)
15719 v(e_RAB_Level_QoS_Parameters);
15721 v(s1_UL_GTPtunnelEndpoint);
15725 template<typename V> void encode(V& v) const
15728 v(e_RAB_Level_QoS_Parameters);
15730 v(s1_UL_GTPtunnelEndpoint);
15737 e_RAB_Level_QoS_Parameters.clear();
15738 dL_Forwarding.clear();
15739 s1_UL_GTPtunnelEndpoint.clear();
15740 iE_Extensions.clear();
15744 e_RAB_ID_t e_RAB_ID;
15745 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
15746 dL_Forwarding_t dL_Forwarding;
15747 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
15748 iE_Extensions_t iE_Extensions;
15752 E-RABs-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15757 struct E_RABs_ToBeAdded_Item_Split_BearerExtIEs
15759 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15761 size_t get_index() const {return type;}
15762 bool is_unknown() const { return type == 1; }
15763 void clear() {type = 0;}
15764 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15765 template<typename V> bool decode(V& v)
15768 if(!v(ref_nested())) return false;
15769 { type = 1; return true;}
15773 template<typename V> bool encode(V& v) const
15775 return v(ref_nested());
15779 template<typename V> bool decode(size_t index, V& v)
15784 case 1: type = 1; return v(ref_nested());
15785 ref_nested().clear();
15790 template<typename V> bool encode(size_t index, V& v) const
15792 if(index != type) {return false;} return v(ref_nested());
15799 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15801 size_t get_index() const {return type;}
15802 bool is_unknown() const { return type == 1; }
15803 void clear() {type = 0;}
15804 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15805 template<typename V> bool decode(V& v)
15808 if(!v(ref_nested())) return false;
15809 { type = 1; return true;}
15813 template<typename V> bool encode(V& v) const
15815 return v(ref_nested());
15819 template<typename V> bool decode(size_t index, V& v)
15824 case 1: type = 1; return v(ref_nested());
15825 ref_nested().clear();
15830 template<typename V> bool encode(size_t index, V& v) const
15832 if(index != type) {return false;} return v(ref_nested());
15839 struct Extension_t : asn::typefield<true>
15841 ~Extension_t() {clear();}
15842 size_t get_index() const {return type;}
15843 bool is_unknown() const { return type == 1; }
15846 type = 0; ref_nested().clear();
15848 template<typename V> static inline void enumerate(V& v)
15853 template<typename V> bool decode(size_t index, V& v)
15858 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
15863 template<typename V> bool encode(size_t index, V& v) const
15865 if(index != type) return false;
15873 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15875 size_t get_index() const {return type;}
15876 bool is_unknown() const { return type == 1; }
15877 void clear() {type = 0;}
15878 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15879 template<typename V> bool decode(V& v)
15882 if(!v(ref_nested())) return false;
15883 { type = 1; return true;}
15887 template<typename V> bool encode(V& v) const
15889 return v(ref_nested());
15893 template<typename V> bool decode(size_t index, V& v)
15898 case 1: type = 1; return v(ref_nested());
15899 ref_nested().clear();
15904 template<typename V> bool encode(size_t index, V& v) const
15906 if(index != type) {return false;} return v(ref_nested());
15916 E-RABs-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
15918 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
15919 meNB-GTPtunnelEndpoint GTPtunnelEndpoint,
15920 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
15925 struct E_RABs_ToBeAdded_Item_Split_Bearer : asn::sequence<4, 0, true, 1>
15927 static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-Split-Bearer";}
15928 using parent_t = asn::sequence<4, 0, true, 1>;
15929 struct e_RAB_ID_t : E_RAB_ID
15931 static constexpr const char* name() {return "e_RAB_ID_t";}
15932 using parent_t = E_RAB_ID;
15935 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15936 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15937 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
15939 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
15940 using parent_t = E_RAB_Level_QoS_Parameters;
15943 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
15944 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
15945 struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
15947 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
15948 using parent_t = GTPtunnelEndpoint;
15951 meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
15952 meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
15953 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>
15955 static constexpr const char* name() {return "iE_Extensions_t";}
15956 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>;
15957 static constexpr bool optional = true;
15960 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15961 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15962 template<typename V> void decode(V& v)
15965 v(e_RAB_Level_QoS_Parameters);
15966 v(meNB_GTPtunnelEndpoint);
15970 template<typename V> void encode(V& v) const
15973 v(e_RAB_Level_QoS_Parameters);
15974 v(meNB_GTPtunnelEndpoint);
15981 e_RAB_Level_QoS_Parameters.clear();
15982 meNB_GTPtunnelEndpoint.clear();
15983 iE_Extensions.clear();
15987 e_RAB_ID_t e_RAB_ID;
15988 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
15989 meNB_GTPtunnelEndpoint_t meNB_GTPtunnelEndpoint;
15990 iE_Extensions_t iE_Extensions;
15994 E-RABs-ToBeAdded-Item ::= CHOICE {
15995 sCG-Bearer E-RABs-ToBeAdded-Item-SCG-Bearer,
15996 split-Bearer E-RABs-ToBeAdded-Item-Split-Bearer,
16001 struct E_RABs_ToBeAdded_Item : asn::choice<2, 0, true>
16003 static constexpr const char* name() {return "E-RABs-ToBeAdded-Item";}
16004 using parent_t = asn::choice<2, 0, true>;
16005 index_type get_index() const {return index;}
16006 bool is_unknown() const {return index == 3;}
16007 void set_unknown() { set_index(3); }
16008 ~E_RABs_ToBeAdded_Item() {clear();}
16009 struct sCG_Bearer_t : E_RABs_ToBeAdded_Item_SCG_Bearer
16011 static constexpr const char* name() {return "sCG_Bearer_t";}
16012 using parent_t = E_RABs_ToBeAdded_Item_SCG_Bearer;
16015 struct split_Bearer_t : E_RABs_ToBeAdded_Item_Split_Bearer
16017 static constexpr const char* name() {return "split_Bearer_t";}
16018 using parent_t = E_RABs_ToBeAdded_Item_Split_Bearer;
16023 switch(get_index())
16025 case 1: var.destroy<sCG_Bearer_t>(); break;
16026 case 2: var.destroy<split_Bearer_t>(); break;
16031 template<typename V> bool decode(size_t idx, V& v)
16036 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
16037 case 2: set_index(2); return v(var.build<split_Bearer_t>());
16042 template<typename V> bool encode(V& v) const
16044 switch(get_index())
16046 case 1: return v(var.as<sCG_Bearer_t>());
16047 case 2: return v(var.as<split_Bearer_t>());
16051 template<typename V> static inline void enumerate(V& v)
16053 v.template operator()<sCG_Bearer_t>(1);
16054 v.template operator()<split_Bearer_t>(2);
16057 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
16058 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
16059 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
16060 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
16062 void set_index(index_type i) {index = i; base::set();}
16065 char dummy1[sizeof(sCG_Bearer_t)];
16066 char dummy2[sizeof(split_Bearer_t)];
16069 asn::variant<sizeof(union_type)> var;
16070 index_type index {0};
16073 E-RABs-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
16074 { ID id-E-RABs-ToBeAdded-Item CRITICALITY reject TYPE E-RABs-ToBeAdded-Item PRESENCE mandatory},
16079 struct E_RABs_ToBeAdded_ItemIEs
16081 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
16083 size_t get_index() const {return type;}
16084 bool is_unknown() const { return type == 2; }
16085 void clear() {type = 0;}
16086 void select_id_E_RABs_ToBeAdded_Item() { set(id_E_RABs_ToBeAdded_Item); type=1;}
16087 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
16088 template<typename V> bool decode(V& v)
16091 if(!v(ref_nested())) return false;
16092 if(equal(id_E_RABs_ToBeAdded_Item)) { type = 1; return true; }
16093 else { type = 2; return true;}
16097 template<typename V> bool encode(V& v) const
16099 return v(ref_nested());
16103 template<typename V> bool decode(size_t index, V& v)
16108 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_Item);} return false;
16109 case 2: type = 2; return v(ref_nested());
16110 ref_nested().clear();
16115 template<typename V> bool encode(size_t index, V& v) const
16117 if(index != type) {return false;} return v(ref_nested());
16124 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
16126 size_t get_index() const {return type;}
16127 bool is_unknown() const { return type == 2; }
16128 void clear() {type = 0;}
16129 void select_id_E_RABs_ToBeAdded_Item() { set(reject); type=1;}
16130 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
16131 template<typename V> bool decode(V& v)
16134 if(!v(ref_nested())) return false;
16135 if(equal(reject)) { type = 1; return true; }
16136 else { type = 2; return true;}
16140 template<typename V> bool encode(V& v) const
16142 return v(ref_nested());
16146 template<typename V> bool decode(size_t index, V& v)
16151 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
16152 case 2: type = 2; return v(ref_nested());
16153 ref_nested().clear();
16158 template<typename V> bool encode(size_t index, V& v) const
16160 if(index != type) {return false;} return v(ref_nested());
16167 struct Value_t : asn::typefield<true>
16169 ~Value_t() {clear();}
16170 size_t get_index() const {return type;}
16171 E_RABs_ToBeAdded_Item& select_id_E_RABs_ToBeAdded_Item() { return set<E_RABs_ToBeAdded_Item>(1); }
16172 E_RABs_ToBeAdded_Item const* get_id_E_RABs_ToBeAdded_Item() const { return get<E_RABs_ToBeAdded_Item>(1); }
16173 bool is_unknown() const { return type == 2; }
16178 case 1: var.destroy<E_RABs_ToBeAdded_Item>(); break;
16180 type = 0; ref_nested().clear();
16182 template<typename V> static inline void enumerate(V& v)
16184 v.template operator()<E_RABs_ToBeAdded_Item>(1);
16188 template<typename V> bool decode(size_t index, V& v)
16193 case 1: v(select_id_E_RABs_ToBeAdded_Item()); return true;
16194 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
16199 template<typename V> bool encode(size_t index, V& v) const
16201 if(index != type) return false;
16204 case 1: v(var.as<E_RABs_ToBeAdded_Item>()); return true;
16210 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16211 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16214 char dummy1[sizeof(E_RABs_ToBeAdded_Item)];
16217 asn::variant<sizeof(union_type)> var;
16221 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
16223 size_t get_index() const {return type;}
16224 bool is_unknown() const { return type == 2; }
16225 void clear() {type = 0;}
16226 void select_id_E_RABs_ToBeAdded_Item() { set(mandatory); type=1;}
16227 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
16228 template<typename V> bool decode(V& v)
16231 if(!v(ref_nested())) return false;
16232 if(equal(mandatory)) { type = 1; return true; }
16233 else { type = 2; return true;}
16237 template<typename V> bool encode(V& v) const
16239 return v(ref_nested());
16243 template<typename V> bool decode(size_t index, V& v)
16248 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
16249 case 2: type = 2; return v(ref_nested());
16250 ref_nested().clear();
16255 template<typename V> bool encode(size_t index, V& v) const
16257 if(index != type) {return false;} return v(ref_nested());
16267 E-RABs-ToBeAdded-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ItemIEs} }
16270 struct E_RABs_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>
16272 static constexpr const char* name() {return "E_RABs_ToBeAdded_List_elm";}
16273 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>;
16276 struct E_RABs_ToBeAdded_List : asn::sequenceof<E_RABs_ToBeAdded_List_elm>
16278 static constexpr const char* name() {return "E-RABs-ToBeAdded-List";}
16279 using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_elm>;
16280 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
16284 E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16285 { ID id-Correlation-ID CRITICALITY ignore EXTENSION Correlation-ID PRESENCE optional}|
16286 { ID id-SIPTO-Correlation-ID CRITICALITY ignore EXTENSION Correlation-ID PRESENCE optional},
16291 struct E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs
16293 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16295 size_t get_index() const {return type;}
16296 bool is_unknown() const { return type == 3; }
16297 void clear() {type = 0;}
16298 void select_id_Correlation_ID() { set(id_Correlation_ID); type=1;}
16299 void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); type=2;}
16300 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16301 template<typename V> bool decode(V& v)
16304 if(!v(ref_nested())) return false;
16305 if(equal(id_Correlation_ID)) { type = 1; return true; }
16306 else if(equal(id_SIPTO_Correlation_ID)) { type = 2; return true; }
16307 else { type = 3; return true;}
16311 template<typename V> bool encode(V& v) const
16313 return v(ref_nested());
16317 template<typename V> bool decode(size_t index, V& v)
16322 case 1: type = 1; if(v(ref_nested())) { return equal(id_Correlation_ID);} return false;
16323 case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} return false;
16324 case 3: type = 3; return v(ref_nested());
16325 ref_nested().clear();
16330 template<typename V> bool encode(size_t index, V& v) const
16332 if(index != type) {return false;} return v(ref_nested());
16339 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16341 size_t get_index() const {return type;}
16342 bool is_unknown() const { return type == 3; }
16343 void clear() {type = 0;}
16344 void select_id_Correlation_ID() { set(ignore); type=1;}
16345 void select_id_SIPTO_Correlation_ID() { set(ignore); type=2;}
16346 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16347 template<typename V> bool decode(V& v)
16350 if(!v(ref_nested())) return false;
16351 if(equal(ignore)) { type = 1; return true; }
16352 else if(equal(ignore)) { type = 2; return true; }
16353 else { type = 3; return true;}
16357 template<typename V> bool encode(V& v) const
16359 return v(ref_nested());
16363 template<typename V> bool decode(size_t index, V& v)
16368 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16369 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
16370 case 3: type = 3; return v(ref_nested());
16371 ref_nested().clear();
16376 template<typename V> bool encode(size_t index, V& v) const
16378 if(index != type) {return false;} return v(ref_nested());
16385 struct Extension_t : asn::typefield<true>
16387 ~Extension_t() {clear();}
16388 size_t get_index() const {return type;}
16389 Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
16390 Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
16391 Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
16392 Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
16393 bool is_unknown() const { return type == 3; }
16398 case 1: var.destroy<Correlation_ID>(); break;
16399 case 2: var.destroy<Correlation_ID>(); break;
16401 type = 0; ref_nested().clear();
16403 template<typename V> static inline void enumerate(V& v)
16405 v.template operator()<Correlation_ID>(1);
16406 v.template operator()<Correlation_ID>(2);
16410 template<typename V> bool decode(size_t index, V& v)
16415 case 1: v(select_id_Correlation_ID()); return true;
16416 case 2: v(select_id_SIPTO_Correlation_ID()); return true;
16417 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
16422 template<typename V> bool encode(size_t index, V& v) const
16424 if(index != type) return false;
16427 case 1: v(var.as<Correlation_ID>()); return true;
16428 case 2: v(var.as<Correlation_ID>()); return true;
16434 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16435 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16438 char dummy1[sizeof(Correlation_ID)];
16441 asn::variant<sizeof(union_type)> var;
16445 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16447 size_t get_index() const {return type;}
16448 bool is_unknown() const { return type == 3; }
16449 void clear() {type = 0;}
16450 void select_id_Correlation_ID() { set(optional); type=1;}
16451 void select_id_SIPTO_Correlation_ID() { set(optional); type=2;}
16452 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16453 template<typename V> bool decode(V& v)
16456 if(!v(ref_nested())) return false;
16457 if(equal(optional)) { type = 1; return true; }
16458 else if(equal(optional)) { type = 2; return true; }
16459 else { type = 3; return true;}
16463 template<typename V> bool encode(V& v) const
16465 return v(ref_nested());
16469 template<typename V> bool decode(size_t index, V& v)
16474 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
16475 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
16476 case 3: type = 3; return v(ref_nested());
16477 ref_nested().clear();
16482 template<typename V> bool encode(size_t index, V& v) const
16484 if(index != type) {return false;} return v(ref_nested());
16494 E-RABs-ToBeAdded-ModReqItem-SCG-Bearer ::= SEQUENCE {
16496 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
16497 dL-Forwarding DL-Forwarding OPTIONAL,
16498 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint,
16499 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
16504 struct E_RABs_ToBeAdded_ModReqItem_SCG_Bearer : asn::sequence<5, 0, true, 2>
16506 static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-SCG-Bearer";}
16507 using parent_t = asn::sequence<5, 0, true, 2>;
16508 struct e_RAB_ID_t : E_RAB_ID
16510 static constexpr const char* name() {return "e_RAB_ID_t";}
16511 using parent_t = E_RAB_ID;
16514 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
16515 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
16516 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
16518 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
16519 using parent_t = E_RAB_Level_QoS_Parameters;
16522 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
16523 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
16524 struct dL_Forwarding_t : DL_Forwarding
16526 static constexpr const char* name() {return "dL_Forwarding_t";}
16527 using parent_t = DL_Forwarding;
16528 static constexpr bool optional = true;
16531 dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
16532 dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
16533 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
16535 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
16536 using parent_t = GTPtunnelEndpoint;
16539 s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
16540 s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
16541 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>
16543 static constexpr const char* name() {return "iE_Extensions_t";}
16544 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>;
16545 static constexpr bool optional = true;
16548 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16549 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16550 template<typename V> void decode(V& v)
16553 v(e_RAB_Level_QoS_Parameters);
16555 v(s1_UL_GTPtunnelEndpoint);
16559 template<typename V> void encode(V& v) const
16562 v(e_RAB_Level_QoS_Parameters);
16564 v(s1_UL_GTPtunnelEndpoint);
16571 e_RAB_Level_QoS_Parameters.clear();
16572 dL_Forwarding.clear();
16573 s1_UL_GTPtunnelEndpoint.clear();
16574 iE_Extensions.clear();
16578 e_RAB_ID_t e_RAB_ID;
16579 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
16580 dL_Forwarding_t dL_Forwarding;
16581 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
16582 iE_Extensions_t iE_Extensions;
16586 E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16591 struct E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs
16593 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16595 size_t get_index() const {return type;}
16596 bool is_unknown() const { return type == 1; }
16597 void clear() {type = 0;}
16598 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16599 template<typename V> bool decode(V& v)
16602 if(!v(ref_nested())) return false;
16603 { type = 1; return true;}
16607 template<typename V> bool encode(V& v) const
16609 return v(ref_nested());
16613 template<typename V> bool decode(size_t index, V& v)
16618 case 1: type = 1; return v(ref_nested());
16619 ref_nested().clear();
16624 template<typename V> bool encode(size_t index, V& v) const
16626 if(index != type) {return false;} return v(ref_nested());
16633 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16635 size_t get_index() const {return type;}
16636 bool is_unknown() const { return type == 1; }
16637 void clear() {type = 0;}
16638 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16639 template<typename V> bool decode(V& v)
16642 if(!v(ref_nested())) return false;
16643 { type = 1; return true;}
16647 template<typename V> bool encode(V& v) const
16649 return v(ref_nested());
16653 template<typename V> bool decode(size_t index, V& v)
16658 case 1: type = 1; return v(ref_nested());
16659 ref_nested().clear();
16664 template<typename V> bool encode(size_t index, V& v) const
16666 if(index != type) {return false;} return v(ref_nested());
16673 struct Extension_t : asn::typefield<true>
16675 ~Extension_t() {clear();}
16676 size_t get_index() const {return type;}
16677 bool is_unknown() const { return type == 1; }
16680 type = 0; ref_nested().clear();
16682 template<typename V> static inline void enumerate(V& v)
16687 template<typename V> bool decode(size_t index, V& v)
16692 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16697 template<typename V> bool encode(size_t index, V& v) const
16699 if(index != type) return false;
16707 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16709 size_t get_index() const {return type;}
16710 bool is_unknown() const { return type == 1; }
16711 void clear() {type = 0;}
16712 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16713 template<typename V> bool decode(V& v)
16716 if(!v(ref_nested())) return false;
16717 { type = 1; return true;}
16721 template<typename V> bool encode(V& v) const
16723 return v(ref_nested());
16727 template<typename V> bool decode(size_t index, V& v)
16732 case 1: type = 1; return v(ref_nested());
16733 ref_nested().clear();
16738 template<typename V> bool encode(size_t index, V& v) const
16740 if(index != type) {return false;} return v(ref_nested());
16750 E-RABs-ToBeAdded-ModReqItem-Split-Bearer ::= SEQUENCE {
16752 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
16753 meNB-GTPtunnelEndpoint GTPtunnelEndpoint,
16754 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
16759 struct E_RABs_ToBeAdded_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 1>
16761 static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-Split-Bearer";}
16762 using parent_t = asn::sequence<4, 0, true, 1>;
16763 struct e_RAB_ID_t : E_RAB_ID
16765 static constexpr const char* name() {return "e_RAB_ID_t";}
16766 using parent_t = E_RAB_ID;
16769 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
16770 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
16771 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
16773 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
16774 using parent_t = E_RAB_Level_QoS_Parameters;
16777 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
16778 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
16779 struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
16781 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
16782 using parent_t = GTPtunnelEndpoint;
16785 meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
16786 meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
16787 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>
16789 static constexpr const char* name() {return "iE_Extensions_t";}
16790 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>;
16791 static constexpr bool optional = true;
16794 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16795 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16796 template<typename V> void decode(V& v)
16799 v(e_RAB_Level_QoS_Parameters);
16800 v(meNB_GTPtunnelEndpoint);
16804 template<typename V> void encode(V& v) const
16807 v(e_RAB_Level_QoS_Parameters);
16808 v(meNB_GTPtunnelEndpoint);
16815 e_RAB_Level_QoS_Parameters.clear();
16816 meNB_GTPtunnelEndpoint.clear();
16817 iE_Extensions.clear();
16821 e_RAB_ID_t e_RAB_ID;
16822 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
16823 meNB_GTPtunnelEndpoint_t meNB_GTPtunnelEndpoint;
16824 iE_Extensions_t iE_Extensions;
16828 E-RABs-ToBeAdded-ModReqItem ::= CHOICE {
16829 sCG-Bearer E-RABs-ToBeAdded-ModReqItem-SCG-Bearer,
16830 split-Bearer E-RABs-ToBeAdded-ModReqItem-Split-Bearer,
16835 struct E_RABs_ToBeAdded_ModReqItem : asn::choice<2, 0, true>
16837 static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem";}
16838 using parent_t = asn::choice<2, 0, true>;
16839 index_type get_index() const {return index;}
16840 bool is_unknown() const {return index == 3;}
16841 void set_unknown() { set_index(3); }
16842 ~E_RABs_ToBeAdded_ModReqItem() {clear();}
16843 struct sCG_Bearer_t : E_RABs_ToBeAdded_ModReqItem_SCG_Bearer
16845 static constexpr const char* name() {return "sCG_Bearer_t";}
16846 using parent_t = E_RABs_ToBeAdded_ModReqItem_SCG_Bearer;
16849 struct split_Bearer_t : E_RABs_ToBeAdded_ModReqItem_Split_Bearer
16851 static constexpr const char* name() {return "split_Bearer_t";}
16852 using parent_t = E_RABs_ToBeAdded_ModReqItem_Split_Bearer;
16857 switch(get_index())
16859 case 1: var.destroy<sCG_Bearer_t>(); break;
16860 case 2: var.destroy<split_Bearer_t>(); break;
16865 template<typename V> bool decode(size_t idx, V& v)
16870 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
16871 case 2: set_index(2); return v(var.build<split_Bearer_t>());
16876 template<typename V> bool encode(V& v) const
16878 switch(get_index())
16880 case 1: return v(var.as<sCG_Bearer_t>());
16881 case 2: return v(var.as<split_Bearer_t>());
16885 template<typename V> static inline void enumerate(V& v)
16887 v.template operator()<sCG_Bearer_t>(1);
16888 v.template operator()<split_Bearer_t>(2);
16891 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
16892 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
16893 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
16894 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
16896 void set_index(index_type i) {index = i; base::set();}
16899 char dummy1[sizeof(sCG_Bearer_t)];
16900 char dummy2[sizeof(split_Bearer_t)];
16903 asn::variant<sizeof(union_type)> var;
16904 index_type index {0};
16907 E-RABs-ToBeAdded-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
16908 { ID id-E-RABs-ToBeAdded-ModReqItem CRITICALITY ignore TYPE E-RABs-ToBeAdded-ModReqItem PRESENCE mandatory},
16913 struct E_RABs_ToBeAdded_ModReqItemIEs
16915 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
16917 size_t get_index() const {return type;}
16918 bool is_unknown() const { return type == 2; }
16919 void clear() {type = 0;}
16920 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(id_E_RABs_ToBeAdded_ModReqItem); type=1;}
16921 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
16922 template<typename V> bool decode(V& v)
16925 if(!v(ref_nested())) return false;
16926 if(equal(id_E_RABs_ToBeAdded_ModReqItem)) { type = 1; return true; }
16927 else { type = 2; return true;}
16931 template<typename V> bool encode(V& v) const
16933 return v(ref_nested());
16937 template<typename V> bool decode(size_t index, V& v)
16942 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_ModReqItem);} return false;
16943 case 2: type = 2; 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 criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
16960 size_t get_index() const {return type;}
16961 bool is_unknown() const { return type == 2; }
16962 void clear() {type = 0;}
16963 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(ignore); type=1;}
16964 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
16965 template<typename V> bool decode(V& v)
16968 if(!v(ref_nested())) return false;
16969 if(equal(ignore)) { type = 1; return true; }
16970 else { type = 2; return true;}
16974 template<typename V> bool encode(V& v) const
16976 return v(ref_nested());
16980 template<typename V> bool decode(size_t index, V& v)
16985 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16986 case 2: type = 2; return v(ref_nested());
16987 ref_nested().clear();
16992 template<typename V> bool encode(size_t index, V& v) const
16994 if(index != type) {return false;} return v(ref_nested());
17001 struct Value_t : asn::typefield<true>
17003 ~Value_t() {clear();}
17004 size_t get_index() const {return type;}
17005 E_RABs_ToBeAdded_ModReqItem& select_id_E_RABs_ToBeAdded_ModReqItem() { return set<E_RABs_ToBeAdded_ModReqItem>(1); }
17006 E_RABs_ToBeAdded_ModReqItem const* get_id_E_RABs_ToBeAdded_ModReqItem() const { return get<E_RABs_ToBeAdded_ModReqItem>(1); }
17007 bool is_unknown() const { return type == 2; }
17012 case 1: var.destroy<E_RABs_ToBeAdded_ModReqItem>(); break;
17014 type = 0; ref_nested().clear();
17016 template<typename V> static inline void enumerate(V& v)
17018 v.template operator()<E_RABs_ToBeAdded_ModReqItem>(1);
17022 template<typename V> bool decode(size_t index, V& v)
17027 case 1: v(select_id_E_RABs_ToBeAdded_ModReqItem()); return true;
17028 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
17033 template<typename V> bool encode(size_t index, V& v) const
17035 if(index != type) return false;
17038 case 1: v(var.as<E_RABs_ToBeAdded_ModReqItem>()); return true;
17044 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17045 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17048 char dummy1[sizeof(E_RABs_ToBeAdded_ModReqItem)];
17051 asn::variant<sizeof(union_type)> var;
17055 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
17057 size_t get_index() const {return type;}
17058 bool is_unknown() const { return type == 2; }
17059 void clear() {type = 0;}
17060 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(mandatory); type=1;}
17061 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
17062 template<typename V> bool decode(V& v)
17065 if(!v(ref_nested())) return false;
17066 if(equal(mandatory)) { type = 1; return true; }
17067 else { type = 2; return true;}
17071 template<typename V> bool encode(V& v) const
17073 return v(ref_nested());
17077 template<typename V> bool decode(size_t index, V& v)
17082 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
17083 case 2: type = 2; return v(ref_nested());
17084 ref_nested().clear();
17089 template<typename V> bool encode(size_t index, V& v) const
17091 if(index != type) {return false;} return v(ref_nested());
17101 E-RABs-ToBeAdded-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ModReqItemIEs} }
17104 struct E_RABs_ToBeAdded_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>
17106 static constexpr const char* name() {return "E_RABs_ToBeAdded_List_ModReq_elm";}
17107 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>;
17110 struct E_RABs_ToBeAdded_List_ModReq : asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>
17112 static constexpr const char* name() {return "E-RABs-ToBeAdded-List-ModReq";}
17113 using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>;
17114 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
17118 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17119 { ID id-RLCMode-transferred CRITICALITY ignore EXTENSION RLCMode PRESENCE optional},
17124 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs
17126 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17128 size_t get_index() const {return type;}
17129 bool is_unknown() const { return type == 2; }
17130 void clear() {type = 0;}
17131 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
17132 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17133 template<typename V> bool decode(V& v)
17136 if(!v(ref_nested())) return false;
17137 if(equal(id_RLCMode_transferred)) { type = 1; return true; }
17138 else { type = 2; return true;}
17142 template<typename V> bool encode(V& v) const
17144 return v(ref_nested());
17148 template<typename V> bool decode(size_t index, V& v)
17153 case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
17154 case 2: type = 2; return v(ref_nested());
17155 ref_nested().clear();
17160 template<typename V> bool encode(size_t index, V& v) const
17162 if(index != type) {return false;} return v(ref_nested());
17169 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17171 size_t get_index() const {return type;}
17172 bool is_unknown() const { return type == 2; }
17173 void clear() {type = 0;}
17174 void select_id_RLCMode_transferred() { set(ignore); type=1;}
17175 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17176 template<typename V> bool decode(V& v)
17179 if(!v(ref_nested())) return false;
17180 if(equal(ignore)) { type = 1; return true; }
17181 else { type = 2; return true;}
17185 template<typename V> bool encode(V& v) const
17187 return v(ref_nested());
17191 template<typename V> bool decode(size_t index, V& v)
17196 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
17197 case 2: type = 2; return v(ref_nested());
17198 ref_nested().clear();
17203 template<typename V> bool encode(size_t index, V& v) const
17205 if(index != type) {return false;} return v(ref_nested());
17212 struct Extension_t : asn::typefield<true>
17214 ~Extension_t() {clear();}
17215 size_t get_index() const {return type;}
17216 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
17217 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
17218 bool is_unknown() const { return type == 2; }
17223 case 1: var.destroy<RLCMode>(); break;
17225 type = 0; ref_nested().clear();
17227 template<typename V> static inline void enumerate(V& v)
17229 v.template operator()<RLCMode>(1);
17233 template<typename V> bool decode(size_t index, V& v)
17238 case 1: v(select_id_RLCMode_transferred()); return true;
17239 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
17244 template<typename V> bool encode(size_t index, V& v) const
17246 if(index != type) return false;
17249 case 1: v(var.as<RLCMode>()); return true;
17255 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17256 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17259 char dummy1[sizeof(RLCMode)];
17262 asn::variant<sizeof(union_type)> var;
17266 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17268 size_t get_index() const {return type;}
17269 bool is_unknown() const { return type == 2; }
17270 void clear() {type = 0;}
17271 void select_id_RLCMode_transferred() { set(optional); type=1;}
17272 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17273 template<typename V> bool decode(V& v)
17276 if(!v(ref_nested())) return false;
17277 if(equal(optional)) { type = 1; return true; }
17278 else { type = 2; return true;}
17282 template<typename V> bool encode(V& v) const
17284 return v(ref_nested());
17288 template<typename V> bool decode(size_t index, V& v)
17293 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
17294 case 2: type = 2; return v(ref_nested());
17295 ref_nested().clear();
17300 template<typename V> bool encode(size_t index, V& v) const
17302 if(index != type) {return false;} return v(ref_nested());
17312 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent ::= SEQUENCE {
17313 full-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
17314 max-MCG-admit-E-RAB-Level-QoS-Parameters GBR-QosInformation OPTIONAL,
17315 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
17316 dL-Forwarding DL-Forwarding OPTIONAL,
17317 meNB-DL-GTP-TEIDatMCG GTPtunnelEndpoint OPTIONAL,
17318 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
17319 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint,
17320 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
17325 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
17327 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent";}
17328 using parent_t = asn::sequence<6, 0, true, 4>;
17329 struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
17331 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
17332 using parent_t = E_RAB_Level_QoS_Parameters;
17335 full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
17336 full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
17337 struct max_MCG_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
17339 static constexpr const char* name() {return "max_MCG_admit_E_RAB_Level_QoS_Parameters_t";}
17340 using parent_t = GBR_QosInformation;
17341 static constexpr bool optional = true;
17344 max_MCG_admit_E_RAB_Level_QoS_Parameters_t& set_max_MCG_admit_E_RAB_Level_QoS_Parameters() { max_MCG_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MCG_admit_E_RAB_Level_QoS_Parameters;}
17345 max_MCG_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MCG_admit_E_RAB_Level_QoS_Parameters() const {return max_MCG_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MCG_admit_E_RAB_Level_QoS_Parameters : nullptr;}
17346 struct dL_Forwarding_t : DL_Forwarding
17348 static constexpr const char* name() {return "dL_Forwarding_t";}
17349 using parent_t = DL_Forwarding;
17350 static constexpr bool optional = true;
17353 dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
17354 dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
17355 struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
17357 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
17358 using parent_t = GTPtunnelEndpoint;
17359 static constexpr bool optional = true;
17362 meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
17363 meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
17364 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
17366 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
17367 using parent_t = GTPtunnelEndpoint;
17370 s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
17371 s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
17372 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>
17374 static constexpr const char* name() {return "iE_Extensions_t";}
17375 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>;
17376 static constexpr bool optional = true;
17379 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17380 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17381 template<typename V> void decode(V& v)
17383 v(full_E_RAB_Level_QoS_Parameters);
17384 v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
17386 v(meNB_DL_GTP_TEIDatMCG);
17387 v(s1_UL_GTPtunnelEndpoint);
17391 template<typename V> void encode(V& v) const
17393 v(full_E_RAB_Level_QoS_Parameters);
17394 v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
17396 v(meNB_DL_GTP_TEIDatMCG);
17397 v(s1_UL_GTPtunnelEndpoint);
17403 full_E_RAB_Level_QoS_Parameters.clear();
17404 max_MCG_admit_E_RAB_Level_QoS_Parameters.clear();
17405 dL_Forwarding.clear();
17406 meNB_DL_GTP_TEIDatMCG.clear();
17407 s1_UL_GTPtunnelEndpoint.clear();
17408 iE_Extensions.clear();
17412 full_E_RAB_Level_QoS_Parameters_t full_E_RAB_Level_QoS_Parameters;
17413 max_MCG_admit_E_RAB_Level_QoS_Parameters_t max_MCG_admit_E_RAB_Level_QoS_Parameters;
17414 dL_Forwarding_t dL_Forwarding;
17415 meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
17416 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
17417 iE_Extensions_t iE_Extensions;
17421 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17422 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
17423 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
17424 { ID id-duplicationActivation CRITICALITY ignore EXTENSION DuplicationActivation PRESENCE optional},
17429 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs
17431 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17433 size_t get_index() const {return type;}
17434 bool is_unknown() const { return type == 4; }
17435 void clear() {type = 0;}
17436 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
17437 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
17438 void select_id_duplicationActivation() { set(id_duplicationActivation); type=3;}
17439 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17440 template<typename V> bool decode(V& v)
17443 if(!v(ref_nested())) return false;
17444 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
17445 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
17446 else if(equal(id_duplicationActivation)) { type = 3; return true; }
17447 else { type = 4; return true;}
17451 template<typename V> bool encode(V& v) const
17453 return v(ref_nested());
17457 template<typename V> bool decode(size_t index, V& v)
17462 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
17463 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
17464 case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} return false;
17465 case 4: type = 4; return v(ref_nested());
17466 ref_nested().clear();
17471 template<typename V> bool encode(size_t index, V& v) const
17473 if(index != type) {return false;} return v(ref_nested());
17480 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17482 size_t get_index() const {return type;}
17483 bool is_unknown() const { return type == 4; }
17484 void clear() {type = 0;}
17485 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
17486 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
17487 void select_id_duplicationActivation() { set(ignore); type=3;}
17488 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17489 template<typename V> bool decode(V& v)
17492 if(!v(ref_nested())) return false;
17493 if(equal(ignore)) { type = 1; return true; }
17494 else if(equal(ignore)) { type = 2; return true; }
17495 else if(equal(ignore)) { type = 3; return true; }
17496 else { type = 4; return true;}
17500 template<typename V> bool encode(V& v) const
17502 return v(ref_nested());
17506 template<typename V> bool decode(size_t index, V& v)
17511 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
17512 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
17513 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
17514 case 4: type = 4; return v(ref_nested());
17515 ref_nested().clear();
17520 template<typename V> bool encode(size_t index, V& v) const
17522 if(index != type) {return false;} return v(ref_nested());
17529 struct Extension_t : asn::typefield<true>
17531 ~Extension_t() {clear();}
17532 size_t get_index() const {return type;}
17533 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
17534 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
17535 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
17536 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
17537 DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
17538 DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
17539 bool is_unknown() const { return type == 4; }
17544 case 1: var.destroy<PDCPSnLength>(); break;
17545 case 2: var.destroy<PDCPSnLength>(); break;
17546 case 3: var.destroy<DuplicationActivation>(); break;
17548 type = 0; ref_nested().clear();
17550 template<typename V> static inline void enumerate(V& v)
17552 v.template operator()<PDCPSnLength>(1);
17553 v.template operator()<PDCPSnLength>(2);
17554 v.template operator()<DuplicationActivation>(3);
17558 template<typename V> bool decode(size_t index, V& v)
17563 case 1: v(select_id_uLpDCPSnLength()); return true;
17564 case 2: v(select_id_dLPDCPSnLength()); return true;
17565 case 3: v(select_id_duplicationActivation()); return true;
17566 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
17571 template<typename V> bool encode(size_t index, V& v) const
17573 if(index != type) return false;
17576 case 1: v(var.as<PDCPSnLength>()); return true;
17577 case 2: v(var.as<PDCPSnLength>()); return true;
17578 case 3: v(var.as<DuplicationActivation>()); return true;
17584 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17585 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17588 char dummy1[sizeof(DuplicationActivation)];
17589 char dummy2[sizeof(PDCPSnLength)];
17592 asn::variant<sizeof(union_type)> var;
17596 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17598 size_t get_index() const {return type;}
17599 bool is_unknown() const { return type == 4; }
17600 void clear() {type = 0;}
17601 void select_id_uLpDCPSnLength() { set(optional); type=1;}
17602 void select_id_dLPDCPSnLength() { set(optional); type=2;}
17603 void select_id_duplicationActivation() { set(optional); type=3;}
17604 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17605 template<typename V> bool decode(V& v)
17608 if(!v(ref_nested())) return false;
17609 if(equal(optional)) { type = 1; return true; }
17610 else if(equal(optional)) { type = 2; return true; }
17611 else if(equal(optional)) { type = 3; return true; }
17612 else { type = 4; return true;}
17616 template<typename V> bool encode(V& v) const
17618 return v(ref_nested());
17622 template<typename V> bool decode(size_t index, V& v)
17627 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
17628 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
17629 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
17630 case 4: type = 4; return v(ref_nested());
17631 ref_nested().clear();
17636 template<typename V> bool encode(size_t index, V& v) const
17638 if(index != type) {return false;} return v(ref_nested());
17648 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
17649 requested-SCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
17650 meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint,
17651 secondary-meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
17653 uL-Configuration ULConfiguration OPTIONAL,
17654 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
17655 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
17660 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
17662 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent";}
17663 using parent_t = asn::sequence<6, 0, true, 3>;
17664 struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
17666 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
17667 using parent_t = E_RAB_Level_QoS_Parameters;
17670 requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
17671 requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
17672 struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
17674 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
17675 using parent_t = GTPtunnelEndpoint;
17678 meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
17679 meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
17680 struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
17682 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
17683 using parent_t = GTPtunnelEndpoint;
17684 static constexpr bool optional = true;
17687 secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
17688 secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
17689 struct rlc_Mode_t : RLCMode
17691 static constexpr const char* name() {return "rlc_Mode_t";}
17692 using parent_t = RLCMode;
17695 rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
17696 rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
17697 struct uL_Configuration_t : ULConfiguration
17699 static constexpr const char* name() {return "uL_Configuration_t";}
17700 using parent_t = ULConfiguration;
17701 static constexpr bool optional = true;
17704 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
17705 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
17706 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>
17708 static constexpr const char* name() {return "iE_Extensions_t";}
17709 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>;
17710 static constexpr bool optional = true;
17713 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17714 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17715 template<typename V> void decode(V& v)
17717 v(requested_SCG_E_RAB_Level_QoS_Parameters);
17718 v(meNB_UL_GTP_TEIDatPDCP);
17719 v(secondary_meNB_UL_GTP_TEIDatPDCP);
17721 v(uL_Configuration);
17725 template<typename V> void encode(V& v) const
17727 v(requested_SCG_E_RAB_Level_QoS_Parameters);
17728 v(meNB_UL_GTP_TEIDatPDCP);
17729 v(secondary_meNB_UL_GTP_TEIDatPDCP);
17731 v(uL_Configuration);
17737 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
17738 meNB_UL_GTP_TEIDatPDCP.clear();
17739 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
17741 uL_Configuration.clear();
17742 iE_Extensions.clear();
17746 requested_SCG_E_RAB_Level_QoS_Parameters_t requested_SCG_E_RAB_Level_QoS_Parameters;
17747 meNB_UL_GTP_TEIDatPDCP_t meNB_UL_GTP_TEIDatPDCP;
17748 secondary_meNB_UL_GTP_TEIDatPDCP_t secondary_meNB_UL_GTP_TEIDatPDCP;
17749 rlc_Mode_t rlc_Mode;
17750 uL_Configuration_t uL_Configuration;
17751 iE_Extensions_t iE_Extensions;
17755 E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17760 struct E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs
17762 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17764 size_t get_index() const {return type;}
17765 bool is_unknown() const { return type == 1; }
17766 void clear() {type = 0;}
17767 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17768 template<typename V> bool decode(V& v)
17771 if(!v(ref_nested())) return false;
17772 { type = 1; return true;}
17776 template<typename V> bool encode(V& v) const
17778 return v(ref_nested());
17782 template<typename V> bool decode(size_t index, V& v)
17787 case 1: type = 1; return v(ref_nested());
17788 ref_nested().clear();
17793 template<typename V> bool encode(size_t index, V& v) const
17795 if(index != type) {return false;} return v(ref_nested());
17802 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17804 size_t get_index() const {return type;}
17805 bool is_unknown() const { return type == 1; }
17806 void clear() {type = 0;}
17807 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17808 template<typename V> bool decode(V& v)
17811 if(!v(ref_nested())) return false;
17812 { type = 1; return true;}
17816 template<typename V> bool encode(V& v) const
17818 return v(ref_nested());
17822 template<typename V> bool decode(size_t index, V& v)
17827 case 1: type = 1; return v(ref_nested());
17828 ref_nested().clear();
17833 template<typename V> bool encode(size_t index, V& v) const
17835 if(index != type) {return false;} return v(ref_nested());
17842 struct Extension_t : asn::typefield<true>
17844 ~Extension_t() {clear();}
17845 size_t get_index() const {return type;}
17846 bool is_unknown() const { return type == 1; }
17849 type = 0; ref_nested().clear();
17851 template<typename V> static inline void enumerate(V& v)
17856 template<typename V> bool decode(size_t index, V& v)
17861 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17866 template<typename V> bool encode(size_t index, V& v) const
17868 if(index != type) return false;
17876 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17878 size_t get_index() const {return type;}
17879 bool is_unknown() const { return type == 1; }
17880 void clear() {type = 0;}
17881 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17882 template<typename V> bool decode(V& v)
17885 if(!v(ref_nested())) return false;
17886 { type = 1; return true;}
17890 template<typename V> bool encode(V& v) const
17892 return v(ref_nested());
17896 template<typename V> bool decode(size_t index, V& v)
17901 case 1: type = 1; return v(ref_nested());
17902 ref_nested().clear();
17907 template<typename V> bool encode(size_t index, V& v) const
17909 if(index != type) {return false;} return v(ref_nested());
17919 E-RABs-ToBeAdded-SgNBAddReq-Item ::= SEQUENCE {
17922 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
17923 resource-configuration CHOICE {
17924 sgNBPDCPpresent E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent,
17925 sgNBPDCPnotpresent E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent,
17928 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs} } OPTIONAL,
17933 struct E_RABs_ToBeAdded_SgNBAddReq_Item : asn::sequence<5, 0, true, 1>
17935 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item";}
17936 using parent_t = asn::sequence<5, 0, true, 1>;
17937 struct e_RAB_ID_t : E_RAB_ID
17939 static constexpr const char* name() {return "e_RAB_ID_t";}
17940 using parent_t = E_RAB_ID;
17943 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
17944 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
17945 struct drb_ID_t : DRB_ID
17947 static constexpr const char* name() {return "drb_ID_t";}
17948 using parent_t = DRB_ID;
17951 drb_ID_t& ref_drb_ID() {return drb_ID;}
17952 drb_ID_t const& ref_drb_ID() const {return drb_ID;}
17953 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
17955 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
17956 using parent_t = EN_DC_ResourceConfiguration;
17959 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
17960 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
17961 struct resource_configuration_t : asn::choice<2, 0, true>
17963 static constexpr const char* name() {return "resource_configuration_t";}
17964 using parent_t = asn::choice<2, 0, true>;
17965 index_type get_index() const {return index;}
17966 bool is_unknown() const {return index == 3;}
17967 void set_unknown() { set_index(3); }
17968 ~resource_configuration_t() {clear();}
17969 struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent
17971 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
17972 using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent;
17975 struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent
17977 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
17978 using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent;
17983 switch(get_index())
17985 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
17986 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
17991 template<typename V> bool decode(size_t idx, V& v)
17996 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
17997 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
18002 template<typename V> bool encode(V& v) const
18004 switch(get_index())
18006 case 1: return v(var.as<sgNBPDCPpresent_t>());
18007 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
18011 template<typename V> static inline void enumerate(V& v)
18013 v.template operator()<sgNBPDCPpresent_t>(1);
18014 v.template operator()<sgNBPDCPnotpresent_t>(2);
18017 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
18018 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
18019 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
18020 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
18022 void set_index(index_type i) {index = i; base::set();}
18025 char dummy1[sizeof(sgNBPDCPpresent_t)];
18026 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
18029 asn::variant<sizeof(union_type)> var;
18030 index_type index {0};
18032 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
18033 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
18034 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>
18036 static constexpr const char* name() {return "iE_Extensions_t";}
18037 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>;
18038 static constexpr bool optional = true;
18041 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18042 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18043 template<typename V> void decode(V& v)
18047 v(en_DC_ResourceConfiguration);
18048 v(resource_configuration);
18052 template<typename V> void encode(V& v) const
18056 v(en_DC_ResourceConfiguration);
18057 v(resource_configuration);
18065 en_DC_ResourceConfiguration.clear();
18066 resource_configuration.clear();
18067 iE_Extensions.clear();
18071 e_RAB_ID_t e_RAB_ID;
18073 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
18074 resource_configuration_t resource_configuration;
18075 iE_Extensions_t iE_Extensions;
18079 E-RABs-ToBeAdded-SgNBAddReq-ItemIEs X2AP-PROTOCOL-IES ::= {
18080 { ID id-E-RABs-ToBeAdded-SgNBAddReq-Item CRITICALITY reject TYPE E-RABs-ToBeAdded-SgNBAddReq-Item PRESENCE mandatory},
18085 struct E_RABs_ToBeAdded_SgNBAddReq_ItemIEs
18087 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
18089 size_t get_index() const {return type;}
18090 bool is_unknown() const { return type == 2; }
18091 void clear() {type = 0;}
18092 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(id_E_RABs_ToBeAdded_SgNBAddReq_Item); type=1;}
18093 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
18094 template<typename V> bool decode(V& v)
18097 if(!v(ref_nested())) return false;
18098 if(equal(id_E_RABs_ToBeAdded_SgNBAddReq_Item)) { type = 1; return true; }
18099 else { type = 2; return true;}
18103 template<typename V> bool encode(V& v) const
18105 return v(ref_nested());
18109 template<typename V> bool decode(size_t index, V& v)
18114 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBAddReq_Item);} return false;
18115 case 2: type = 2; return v(ref_nested());
18116 ref_nested().clear();
18121 template<typename V> bool encode(size_t index, V& v) const
18123 if(index != type) {return false;} return v(ref_nested());
18130 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
18132 size_t get_index() const {return type;}
18133 bool is_unknown() const { return type == 2; }
18134 void clear() {type = 0;}
18135 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(reject); type=1;}
18136 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
18137 template<typename V> bool decode(V& v)
18140 if(!v(ref_nested())) return false;
18141 if(equal(reject)) { type = 1; return true; }
18142 else { type = 2; return true;}
18146 template<typename V> bool encode(V& v) const
18148 return v(ref_nested());
18152 template<typename V> bool decode(size_t index, V& v)
18157 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
18158 case 2: type = 2; return v(ref_nested());
18159 ref_nested().clear();
18164 template<typename V> bool encode(size_t index, V& v) const
18166 if(index != type) {return false;} return v(ref_nested());
18173 struct Value_t : asn::typefield<true>
18175 ~Value_t() {clear();}
18176 size_t get_index() const {return type;}
18177 E_RABs_ToBeAdded_SgNBAddReq_Item& select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { return set<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
18178 E_RABs_ToBeAdded_SgNBAddReq_Item const* get_id_E_RABs_ToBeAdded_SgNBAddReq_Item() const { return get<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
18179 bool is_unknown() const { return type == 2; }
18184 case 1: var.destroy<E_RABs_ToBeAdded_SgNBAddReq_Item>(); break;
18186 type = 0; ref_nested().clear();
18188 template<typename V> static inline void enumerate(V& v)
18190 v.template operator()<E_RABs_ToBeAdded_SgNBAddReq_Item>(1);
18194 template<typename V> bool decode(size_t index, V& v)
18199 case 1: v(select_id_E_RABs_ToBeAdded_SgNBAddReq_Item()); return true;
18200 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
18205 template<typename V> bool encode(size_t index, V& v) const
18207 if(index != type) return false;
18210 case 1: v(var.as<E_RABs_ToBeAdded_SgNBAddReq_Item>()); return true;
18216 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18217 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18220 char dummy1[sizeof(E_RABs_ToBeAdded_SgNBAddReq_Item)];
18223 asn::variant<sizeof(union_type)> var;
18227 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
18229 size_t get_index() const {return type;}
18230 bool is_unknown() const { return type == 2; }
18231 void clear() {type = 0;}
18232 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(mandatory); type=1;}
18233 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
18234 template<typename V> bool decode(V& v)
18237 if(!v(ref_nested())) return false;
18238 if(equal(mandatory)) { type = 1; return true; }
18239 else { type = 2; return true;}
18243 template<typename V> bool encode(V& v) const
18245 return v(ref_nested());
18249 template<typename V> bool decode(size_t index, V& v)
18254 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
18255 case 2: type = 2; return v(ref_nested());
18256 ref_nested().clear();
18261 template<typename V> bool encode(size_t index, V& v) const
18263 if(index != type) {return false;} return v(ref_nested());
18273 E-RABs-ToBeAdded-SgNBAddReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBAddReq-ItemIEs} }
18276 struct E_RABs_ToBeAdded_SgNBAddReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>
18278 static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBAddReqList_elm";}
18279 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>;
18282 struct E_RABs_ToBeAdded_SgNBAddReqList : asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>
18284 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReqList";}
18285 using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>;
18286 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
18290 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18291 { ID id-RLCMode-transferred CRITICALITY ignore EXTENSION RLCMode PRESENCE optional},
18296 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs
18298 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18300 size_t get_index() const {return type;}
18301 bool is_unknown() const { return type == 2; }
18302 void clear() {type = 0;}
18303 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
18304 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18305 template<typename V> bool decode(V& v)
18308 if(!v(ref_nested())) return false;
18309 if(equal(id_RLCMode_transferred)) { type = 1; return true; }
18310 else { type = 2; return true;}
18314 template<typename V> bool encode(V& v) const
18316 return v(ref_nested());
18320 template<typename V> bool decode(size_t index, V& v)
18325 case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
18326 case 2: type = 2; return v(ref_nested());
18327 ref_nested().clear();
18332 template<typename V> bool encode(size_t index, V& v) const
18334 if(index != type) {return false;} return v(ref_nested());
18341 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18343 size_t get_index() const {return type;}
18344 bool is_unknown() const { return type == 2; }
18345 void clear() {type = 0;}
18346 void select_id_RLCMode_transferred() { set(ignore); type=1;}
18347 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18348 template<typename V> bool decode(V& v)
18351 if(!v(ref_nested())) return false;
18352 if(equal(ignore)) { type = 1; return true; }
18353 else { type = 2; return true;}
18357 template<typename V> bool encode(V& v) const
18359 return v(ref_nested());
18363 template<typename V> bool decode(size_t index, V& v)
18368 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
18369 case 2: type = 2; return v(ref_nested());
18370 ref_nested().clear();
18375 template<typename V> bool encode(size_t index, V& v) const
18377 if(index != type) {return false;} return v(ref_nested());
18384 struct Extension_t : asn::typefield<true>
18386 ~Extension_t() {clear();}
18387 size_t get_index() const {return type;}
18388 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
18389 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
18390 bool is_unknown() const { return type == 2; }
18395 case 1: var.destroy<RLCMode>(); break;
18397 type = 0; ref_nested().clear();
18399 template<typename V> static inline void enumerate(V& v)
18401 v.template operator()<RLCMode>(1);
18405 template<typename V> bool decode(size_t index, V& v)
18410 case 1: v(select_id_RLCMode_transferred()); return true;
18411 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
18416 template<typename V> bool encode(size_t index, V& v) const
18418 if(index != type) return false;
18421 case 1: v(var.as<RLCMode>()); return true;
18427 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18428 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18431 char dummy1[sizeof(RLCMode)];
18434 asn::variant<sizeof(union_type)> var;
18438 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18440 size_t get_index() const {return type;}
18441 bool is_unknown() const { return type == 2; }
18442 void clear() {type = 0;}
18443 void select_id_RLCMode_transferred() { set(optional); type=1;}
18444 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18445 template<typename V> bool decode(V& v)
18448 if(!v(ref_nested())) return false;
18449 if(equal(optional)) { type = 1; return true; }
18450 else { type = 2; return true;}
18454 template<typename V> bool encode(V& v) const
18456 return v(ref_nested());
18460 template<typename V> bool decode(size_t index, V& v)
18465 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
18466 case 2: type = 2; return v(ref_nested());
18467 ref_nested().clear();
18472 template<typename V> bool encode(size_t index, V& v) const
18474 if(index != type) {return false;} return v(ref_nested());
18484 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
18485 full-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
18486 max-MN-admit-E-RAB-Level-QoS-Parameters GBR-QosInformation OPTIONAL,
18487 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
18488 dL-Forwarding DL-Forwarding OPTIONAL,
18489 meNB-DL-GTP-TEIDatMCG GTPtunnelEndpoint OPTIONAL,
18490 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
18491 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint,
18492 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
18497 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
18499 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent";}
18500 using parent_t = asn::sequence<6, 0, true, 4>;
18501 struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
18503 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
18504 using parent_t = E_RAB_Level_QoS_Parameters;
18507 full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
18508 full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
18509 struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
18511 static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
18512 using parent_t = GBR_QosInformation;
18513 static constexpr bool optional = true;
18516 max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
18517 max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
18518 struct dL_Forwarding_t : DL_Forwarding
18520 static constexpr const char* name() {return "dL_Forwarding_t";}
18521 using parent_t = DL_Forwarding;
18522 static constexpr bool optional = true;
18525 dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
18526 dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
18527 struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
18529 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
18530 using parent_t = GTPtunnelEndpoint;
18531 static constexpr bool optional = true;
18534 meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
18535 meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
18536 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
18538 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
18539 using parent_t = GTPtunnelEndpoint;
18542 s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
18543 s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
18544 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
18546 static constexpr const char* name() {return "iE_Extensions_t";}
18547 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
18548 static constexpr bool optional = true;
18551 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18552 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18553 template<typename V> void decode(V& v)
18555 v(full_E_RAB_Level_QoS_Parameters);
18556 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
18558 v(meNB_DL_GTP_TEIDatMCG);
18559 v(s1_UL_GTPtunnelEndpoint);
18563 template<typename V> void encode(V& v) const
18565 v(full_E_RAB_Level_QoS_Parameters);
18566 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
18568 v(meNB_DL_GTP_TEIDatMCG);
18569 v(s1_UL_GTPtunnelEndpoint);
18575 full_E_RAB_Level_QoS_Parameters.clear();
18576 max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
18577 dL_Forwarding.clear();
18578 meNB_DL_GTP_TEIDatMCG.clear();
18579 s1_UL_GTPtunnelEndpoint.clear();
18580 iE_Extensions.clear();
18584 full_E_RAB_Level_QoS_Parameters_t full_E_RAB_Level_QoS_Parameters;
18585 max_MN_admit_E_RAB_Level_QoS_Parameters_t max_MN_admit_E_RAB_Level_QoS_Parameters;
18586 dL_Forwarding_t dL_Forwarding;
18587 meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
18588 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
18589 iE_Extensions_t iE_Extensions;
18593 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18594 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
18595 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
18596 { ID id-duplicationActivation CRITICALITY ignore EXTENSION DuplicationActivation PRESENCE optional},
18601 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
18603 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18605 size_t get_index() const {return type;}
18606 bool is_unknown() const { return type == 4; }
18607 void clear() {type = 0;}
18608 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
18609 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
18610 void select_id_duplicationActivation() { set(id_duplicationActivation); type=3;}
18611 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18612 template<typename V> bool decode(V& v)
18615 if(!v(ref_nested())) return false;
18616 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
18617 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
18618 else if(equal(id_duplicationActivation)) { type = 3; return true; }
18619 else { type = 4; return true;}
18623 template<typename V> bool encode(V& v) const
18625 return v(ref_nested());
18629 template<typename V> bool decode(size_t index, V& v)
18634 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
18635 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
18636 case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} return false;
18637 case 4: type = 4; return v(ref_nested());
18638 ref_nested().clear();
18643 template<typename V> bool encode(size_t index, V& v) const
18645 if(index != type) {return false;} return v(ref_nested());
18652 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18654 size_t get_index() const {return type;}
18655 bool is_unknown() const { return type == 4; }
18656 void clear() {type = 0;}
18657 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
18658 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
18659 void select_id_duplicationActivation() { set(ignore); type=3;}
18660 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18661 template<typename V> bool decode(V& v)
18664 if(!v(ref_nested())) return false;
18665 if(equal(ignore)) { type = 1; return true; }
18666 else if(equal(ignore)) { type = 2; return true; }
18667 else if(equal(ignore)) { type = 3; return true; }
18668 else { type = 4; return true;}
18672 template<typename V> bool encode(V& v) const
18674 return v(ref_nested());
18678 template<typename V> bool decode(size_t index, V& v)
18683 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
18684 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
18685 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
18686 case 4: type = 4; return v(ref_nested());
18687 ref_nested().clear();
18692 template<typename V> bool encode(size_t index, V& v) const
18694 if(index != type) {return false;} return v(ref_nested());
18701 struct Extension_t : asn::typefield<true>
18703 ~Extension_t() {clear();}
18704 size_t get_index() const {return type;}
18705 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
18706 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
18707 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
18708 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
18709 DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
18710 DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
18711 bool is_unknown() const { return type == 4; }
18716 case 1: var.destroy<PDCPSnLength>(); break;
18717 case 2: var.destroy<PDCPSnLength>(); break;
18718 case 3: var.destroy<DuplicationActivation>(); break;
18720 type = 0; ref_nested().clear();
18722 template<typename V> static inline void enumerate(V& v)
18724 v.template operator()<PDCPSnLength>(1);
18725 v.template operator()<PDCPSnLength>(2);
18726 v.template operator()<DuplicationActivation>(3);
18730 template<typename V> bool decode(size_t index, V& v)
18735 case 1: v(select_id_uLpDCPSnLength()); return true;
18736 case 2: v(select_id_dLPDCPSnLength()); return true;
18737 case 3: v(select_id_duplicationActivation()); return true;
18738 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
18743 template<typename V> bool encode(size_t index, V& v) const
18745 if(index != type) return false;
18748 case 1: v(var.as<PDCPSnLength>()); return true;
18749 case 2: v(var.as<PDCPSnLength>()); return true;
18750 case 3: v(var.as<DuplicationActivation>()); return true;
18756 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18757 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18760 char dummy1[sizeof(DuplicationActivation)];
18761 char dummy2[sizeof(PDCPSnLength)];
18764 asn::variant<sizeof(union_type)> var;
18768 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18770 size_t get_index() const {return type;}
18771 bool is_unknown() const { return type == 4; }
18772 void clear() {type = 0;}
18773 void select_id_uLpDCPSnLength() { set(optional); type=1;}
18774 void select_id_dLPDCPSnLength() { set(optional); type=2;}
18775 void select_id_duplicationActivation() { set(optional); type=3;}
18776 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18777 template<typename V> bool decode(V& v)
18780 if(!v(ref_nested())) return false;
18781 if(equal(optional)) { type = 1; return true; }
18782 else if(equal(optional)) { type = 2; return true; }
18783 else if(equal(optional)) { type = 3; return true; }
18784 else { type = 4; return true;}
18788 template<typename V> bool encode(V& v) const
18790 return v(ref_nested());
18794 template<typename V> bool decode(size_t index, V& v)
18799 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
18800 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
18801 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
18802 case 4: type = 4; return v(ref_nested());
18803 ref_nested().clear();
18808 template<typename V> bool encode(size_t index, V& v) const
18810 if(index != type) {return false;} return v(ref_nested());
18820 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
18821 requested-SCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
18822 meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint,
18823 secondary-meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
18825 uL-Configuration ULConfiguration OPTIONAL,
18826 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
18827 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
18832 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
18834 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent";}
18835 using parent_t = asn::sequence<6, 0, true, 3>;
18836 struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
18838 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
18839 using parent_t = E_RAB_Level_QoS_Parameters;
18842 requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
18843 requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
18844 struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
18846 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
18847 using parent_t = GTPtunnelEndpoint;
18850 meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
18851 meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
18852 struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
18854 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
18855 using parent_t = GTPtunnelEndpoint;
18856 static constexpr bool optional = true;
18859 secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
18860 secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
18861 struct rlc_Mode_t : RLCMode
18863 static constexpr const char* name() {return "rlc_Mode_t";}
18864 using parent_t = RLCMode;
18867 rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
18868 rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
18869 struct uL_Configuration_t : ULConfiguration
18871 static constexpr const char* name() {return "uL_Configuration_t";}
18872 using parent_t = ULConfiguration;
18873 static constexpr bool optional = true;
18876 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
18877 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
18878 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
18880 static constexpr const char* name() {return "iE_Extensions_t";}
18881 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
18882 static constexpr bool optional = true;
18885 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18886 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18887 template<typename V> void decode(V& v)
18889 v(requested_SCG_E_RAB_Level_QoS_Parameters);
18890 v(meNB_UL_GTP_TEIDatPDCP);
18891 v(secondary_meNB_UL_GTP_TEIDatPDCP);
18893 v(uL_Configuration);
18897 template<typename V> void encode(V& v) const
18899 v(requested_SCG_E_RAB_Level_QoS_Parameters);
18900 v(meNB_UL_GTP_TEIDatPDCP);
18901 v(secondary_meNB_UL_GTP_TEIDatPDCP);
18903 v(uL_Configuration);
18909 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
18910 meNB_UL_GTP_TEIDatPDCP.clear();
18911 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
18913 uL_Configuration.clear();
18914 iE_Extensions.clear();
18918 requested_SCG_E_RAB_Level_QoS_Parameters_t requested_SCG_E_RAB_Level_QoS_Parameters;
18919 meNB_UL_GTP_TEIDatPDCP_t meNB_UL_GTP_TEIDatPDCP;
18920 secondary_meNB_UL_GTP_TEIDatPDCP_t secondary_meNB_UL_GTP_TEIDatPDCP;
18921 rlc_Mode_t rlc_Mode;
18922 uL_Configuration_t uL_Configuration;
18923 iE_Extensions_t iE_Extensions;
18927 E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18932 struct E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs
18934 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18936 size_t get_index() const {return type;}
18937 bool is_unknown() const { return type == 1; }
18938 void clear() {type = 0;}
18939 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18940 template<typename V> bool decode(V& v)
18943 if(!v(ref_nested())) return false;
18944 { type = 1; return true;}
18948 template<typename V> bool encode(V& v) const
18950 return v(ref_nested());
18954 template<typename V> bool decode(size_t index, V& v)
18959 case 1: type = 1; return v(ref_nested());
18960 ref_nested().clear();
18965 template<typename V> bool encode(size_t index, V& v) const
18967 if(index != type) {return false;} return v(ref_nested());
18974 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18976 size_t get_index() const {return type;}
18977 bool is_unknown() const { return type == 1; }
18978 void clear() {type = 0;}
18979 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18980 template<typename V> bool decode(V& v)
18983 if(!v(ref_nested())) return false;
18984 { type = 1; return true;}
18988 template<typename V> bool encode(V& v) const
18990 return v(ref_nested());
18994 template<typename V> bool decode(size_t index, V& v)
18999 case 1: type = 1; return v(ref_nested());
19000 ref_nested().clear();
19005 template<typename V> bool encode(size_t index, V& v) const
19007 if(index != type) {return false;} return v(ref_nested());
19014 struct Extension_t : asn::typefield<true>
19016 ~Extension_t() {clear();}
19017 size_t get_index() const {return type;}
19018 bool is_unknown() const { return type == 1; }
19021 type = 0; ref_nested().clear();
19023 template<typename V> static inline void enumerate(V& v)
19028 template<typename V> bool decode(size_t index, V& v)
19033 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19038 template<typename V> bool encode(size_t index, V& v) const
19040 if(index != type) return false;
19048 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19050 size_t get_index() const {return type;}
19051 bool is_unknown() const { return type == 1; }
19052 void clear() {type = 0;}
19053 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19054 template<typename V> bool decode(V& v)
19057 if(!v(ref_nested())) return false;
19058 { type = 1; return true;}
19062 template<typename V> bool encode(V& v) const
19064 return v(ref_nested());
19068 template<typename V> bool decode(size_t index, V& v)
19073 case 1: type = 1; return v(ref_nested());
19074 ref_nested().clear();
19079 template<typename V> bool encode(size_t index, V& v) const
19081 if(index != type) {return false;} return v(ref_nested());
19091 E-RABs-ToBeAdded-SgNBModReq-Item ::= SEQUENCE {
19094 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
19095 resource-configuration CHOICE {
19096 sgNBPDCPpresent E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent,
19097 sgNBPDCPnotpresent E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent,
19100 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs} } OPTIONAL,
19105 struct E_RABs_ToBeAdded_SgNBModReq_Item : asn::sequence<5, 0, true, 1>
19107 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item";}
19108 using parent_t = asn::sequence<5, 0, true, 1>;
19109 struct e_RAB_ID_t : E_RAB_ID
19111 static constexpr const char* name() {return "e_RAB_ID_t";}
19112 using parent_t = E_RAB_ID;
19115 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19116 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19117 struct drb_ID_t : DRB_ID
19119 static constexpr const char* name() {return "drb_ID_t";}
19120 using parent_t = DRB_ID;
19123 drb_ID_t& ref_drb_ID() {return drb_ID;}
19124 drb_ID_t const& ref_drb_ID() const {return drb_ID;}
19125 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
19127 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
19128 using parent_t = EN_DC_ResourceConfiguration;
19131 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
19132 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
19133 struct resource_configuration_t : asn::choice<2, 0, true>
19135 static constexpr const char* name() {return "resource_configuration_t";}
19136 using parent_t = asn::choice<2, 0, true>;
19137 index_type get_index() const {return index;}
19138 bool is_unknown() const {return index == 3;}
19139 void set_unknown() { set_index(3); }
19140 ~resource_configuration_t() {clear();}
19141 struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent
19143 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
19144 using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent;
19147 struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent
19149 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
19150 using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent;
19155 switch(get_index())
19157 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
19158 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
19163 template<typename V> bool decode(size_t idx, V& v)
19168 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
19169 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
19174 template<typename V> bool encode(V& v) const
19176 switch(get_index())
19178 case 1: return v(var.as<sgNBPDCPpresent_t>());
19179 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
19183 template<typename V> static inline void enumerate(V& v)
19185 v.template operator()<sgNBPDCPpresent_t>(1);
19186 v.template operator()<sgNBPDCPnotpresent_t>(2);
19189 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
19190 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
19191 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
19192 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
19194 void set_index(index_type i) {index = i; base::set();}
19197 char dummy1[sizeof(sgNBPDCPpresent_t)];
19198 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
19201 asn::variant<sizeof(union_type)> var;
19202 index_type index {0};
19204 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
19205 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
19206 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>
19208 static constexpr const char* name() {return "iE_Extensions_t";}
19209 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>;
19210 static constexpr bool optional = true;
19213 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19214 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19215 template<typename V> void decode(V& v)
19219 v(en_DC_ResourceConfiguration);
19220 v(resource_configuration);
19224 template<typename V> void encode(V& v) const
19228 v(en_DC_ResourceConfiguration);
19229 v(resource_configuration);
19237 en_DC_ResourceConfiguration.clear();
19238 resource_configuration.clear();
19239 iE_Extensions.clear();
19243 e_RAB_ID_t e_RAB_ID;
19245 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
19246 resource_configuration_t resource_configuration;
19247 iE_Extensions_t iE_Extensions;
19251 E-RABs-ToBeAdded-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
19252 { ID id-E-RABs-ToBeAdded-SgNBModReq-Item CRITICALITY ignore TYPE E-RABs-ToBeAdded-SgNBModReq-Item PRESENCE mandatory},
19257 struct E_RABs_ToBeAdded_SgNBModReq_ItemIEs
19259 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
19261 size_t get_index() const {return type;}
19262 bool is_unknown() const { return type == 2; }
19263 void clear() {type = 0;}
19264 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(id_E_RABs_ToBeAdded_SgNBModReq_Item); type=1;}
19265 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
19266 template<typename V> bool decode(V& v)
19269 if(!v(ref_nested())) return false;
19270 if(equal(id_E_RABs_ToBeAdded_SgNBModReq_Item)) { type = 1; return true; }
19271 else { type = 2; return true;}
19275 template<typename V> bool encode(V& v) const
19277 return v(ref_nested());
19281 template<typename V> bool decode(size_t index, V& v)
19286 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBModReq_Item);} return false;
19287 case 2: type = 2; return v(ref_nested());
19288 ref_nested().clear();
19293 template<typename V> bool encode(size_t index, V& v) const
19295 if(index != type) {return false;} return v(ref_nested());
19302 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
19304 size_t get_index() const {return type;}
19305 bool is_unknown() const { return type == 2; }
19306 void clear() {type = 0;}
19307 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(ignore); type=1;}
19308 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
19309 template<typename V> bool decode(V& v)
19312 if(!v(ref_nested())) return false;
19313 if(equal(ignore)) { type = 1; return true; }
19314 else { type = 2; return true;}
19318 template<typename V> bool encode(V& v) const
19320 return v(ref_nested());
19324 template<typename V> bool decode(size_t index, V& v)
19329 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
19330 case 2: type = 2; return v(ref_nested());
19331 ref_nested().clear();
19336 template<typename V> bool encode(size_t index, V& v) const
19338 if(index != type) {return false;} return v(ref_nested());
19345 struct Value_t : asn::typefield<true>
19347 ~Value_t() {clear();}
19348 size_t get_index() const {return type;}
19349 E_RABs_ToBeAdded_SgNBModReq_Item& select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { return set<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
19350 E_RABs_ToBeAdded_SgNBModReq_Item const* get_id_E_RABs_ToBeAdded_SgNBModReq_Item() const { return get<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
19351 bool is_unknown() const { return type == 2; }
19356 case 1: var.destroy<E_RABs_ToBeAdded_SgNBModReq_Item>(); break;
19358 type = 0; ref_nested().clear();
19360 template<typename V> static inline void enumerate(V& v)
19362 v.template operator()<E_RABs_ToBeAdded_SgNBModReq_Item>(1);
19366 template<typename V> bool decode(size_t index, V& v)
19371 case 1: v(select_id_E_RABs_ToBeAdded_SgNBModReq_Item()); return true;
19372 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
19377 template<typename V> bool encode(size_t index, V& v) const
19379 if(index != type) return false;
19382 case 1: v(var.as<E_RABs_ToBeAdded_SgNBModReq_Item>()); return true;
19388 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
19389 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
19392 char dummy1[sizeof(E_RABs_ToBeAdded_SgNBModReq_Item)];
19395 asn::variant<sizeof(union_type)> var;
19399 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
19401 size_t get_index() const {return type;}
19402 bool is_unknown() const { return type == 2; }
19403 void clear() {type = 0;}
19404 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(mandatory); type=1;}
19405 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
19406 template<typename V> bool decode(V& v)
19409 if(!v(ref_nested())) return false;
19410 if(equal(mandatory)) { type = 1; return true; }
19411 else { type = 2; return true;}
19415 template<typename V> bool encode(V& v) const
19417 return v(ref_nested());
19421 template<typename V> bool decode(size_t index, V& v)
19426 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
19427 case 2: type = 2; return v(ref_nested());
19428 ref_nested().clear();
19433 template<typename V> bool encode(size_t index, V& v) const
19435 if(index != type) {return false;} return v(ref_nested());
19445 E-RABs-ToBeAdded-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBModReq-ItemIEs} }
19448 struct E_RABs_ToBeAdded_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>
19450 static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBModReq_List_elm";}
19451 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>;
19454 struct E_RABs_ToBeAdded_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>
19456 static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-List";}
19457 using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>;
19458 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
19462 E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19467 struct E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs
19469 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19471 size_t get_index() const {return type;}
19472 bool is_unknown() const { return type == 1; }
19473 void clear() {type = 0;}
19474 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19475 template<typename V> bool decode(V& v)
19478 if(!v(ref_nested())) return false;
19479 { type = 1; return true;}
19483 template<typename V> bool encode(V& v) const
19485 return v(ref_nested());
19489 template<typename V> bool decode(size_t index, V& v)
19494 case 1: type = 1; return v(ref_nested());
19495 ref_nested().clear();
19500 template<typename V> bool encode(size_t index, V& v) const
19502 if(index != type) {return false;} return v(ref_nested());
19509 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19511 size_t get_index() const {return type;}
19512 bool is_unknown() const { return type == 1; }
19513 void clear() {type = 0;}
19514 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19515 template<typename V> bool decode(V& v)
19518 if(!v(ref_nested())) return false;
19519 { type = 1; return true;}
19523 template<typename V> bool encode(V& v) const
19525 return v(ref_nested());
19529 template<typename V> bool decode(size_t index, V& v)
19534 case 1: type = 1; return v(ref_nested());
19535 ref_nested().clear();
19540 template<typename V> bool encode(size_t index, V& v) const
19542 if(index != type) {return false;} return v(ref_nested());
19549 struct Extension_t : asn::typefield<true>
19551 ~Extension_t() {clear();}
19552 size_t get_index() const {return type;}
19553 bool is_unknown() const { return type == 1; }
19556 type = 0; ref_nested().clear();
19558 template<typename V> static inline void enumerate(V& v)
19563 template<typename V> bool decode(size_t index, V& v)
19568 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19573 template<typename V> bool encode(size_t index, V& v) const
19575 if(index != type) return false;
19583 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19585 size_t get_index() const {return type;}
19586 bool is_unknown() const { return type == 1; }
19587 void clear() {type = 0;}
19588 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19589 template<typename V> bool decode(V& v)
19592 if(!v(ref_nested())) return false;
19593 { type = 1; return true;}
19597 template<typename V> bool encode(V& v) const
19599 return v(ref_nested());
19603 template<typename V> bool decode(size_t index, V& v)
19608 case 1: type = 1; return v(ref_nested());
19609 ref_nested().clear();
19614 template<typename V> bool encode(size_t index, V& v) const
19616 if(index != type) {return false;} return v(ref_nested());
19626 E-RABs-ToBeModified-ModReqItem-SCG-Bearer ::= SEQUENCE {
19628 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
19629 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
19630 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
19635 struct E_RABs_ToBeModified_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
19637 static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-SCG-Bearer";}
19638 using parent_t = asn::sequence<4, 0, true, 3>;
19639 struct e_RAB_ID_t : E_RAB_ID
19641 static constexpr const char* name() {return "e_RAB_ID_t";}
19642 using parent_t = E_RAB_ID;
19645 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19646 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19647 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
19649 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
19650 using parent_t = E_RAB_Level_QoS_Parameters;
19651 static constexpr bool optional = true;
19654 e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
19655 e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
19656 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
19658 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
19659 using parent_t = GTPtunnelEndpoint;
19660 static constexpr bool optional = true;
19663 s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
19664 s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
19665 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>
19667 static constexpr const char* name() {return "iE_Extensions_t";}
19668 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>;
19669 static constexpr bool optional = true;
19672 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19673 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19674 template<typename V> void decode(V& v)
19677 v(e_RAB_Level_QoS_Parameters);
19678 v(s1_UL_GTPtunnelEndpoint);
19682 template<typename V> void encode(V& v) const
19685 v(e_RAB_Level_QoS_Parameters);
19686 v(s1_UL_GTPtunnelEndpoint);
19693 e_RAB_Level_QoS_Parameters.clear();
19694 s1_UL_GTPtunnelEndpoint.clear();
19695 iE_Extensions.clear();
19699 e_RAB_ID_t e_RAB_ID;
19700 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
19701 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
19702 iE_Extensions_t iE_Extensions;
19706 E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19711 struct E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs
19713 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19715 size_t get_index() const {return type;}
19716 bool is_unknown() const { return type == 1; }
19717 void clear() {type = 0;}
19718 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19719 template<typename V> bool decode(V& v)
19722 if(!v(ref_nested())) return false;
19723 { type = 1; return true;}
19727 template<typename V> bool encode(V& v) const
19729 return v(ref_nested());
19733 template<typename V> bool decode(size_t index, V& v)
19738 case 1: type = 1; return v(ref_nested());
19739 ref_nested().clear();
19744 template<typename V> bool encode(size_t index, V& v) const
19746 if(index != type) {return false;} return v(ref_nested());
19753 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19755 size_t get_index() const {return type;}
19756 bool is_unknown() const { return type == 1; }
19757 void clear() {type = 0;}
19758 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19759 template<typename V> bool decode(V& v)
19762 if(!v(ref_nested())) return false;
19763 { type = 1; return true;}
19767 template<typename V> bool encode(V& v) const
19769 return v(ref_nested());
19773 template<typename V> bool decode(size_t index, V& v)
19778 case 1: type = 1; return v(ref_nested());
19779 ref_nested().clear();
19784 template<typename V> bool encode(size_t index, V& v) const
19786 if(index != type) {return false;} return v(ref_nested());
19793 struct Extension_t : asn::typefield<true>
19795 ~Extension_t() {clear();}
19796 size_t get_index() const {return type;}
19797 bool is_unknown() const { return type == 1; }
19800 type = 0; ref_nested().clear();
19802 template<typename V> static inline void enumerate(V& v)
19807 template<typename V> bool decode(size_t index, V& v)
19812 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19817 template<typename V> bool encode(size_t index, V& v) const
19819 if(index != type) return false;
19827 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19829 size_t get_index() const {return type;}
19830 bool is_unknown() const { return type == 1; }
19831 void clear() {type = 0;}
19832 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19833 template<typename V> bool decode(V& v)
19836 if(!v(ref_nested())) return false;
19837 { type = 1; return true;}
19841 template<typename V> bool encode(V& v) const
19843 return v(ref_nested());
19847 template<typename V> bool decode(size_t index, V& v)
19852 case 1: type = 1; return v(ref_nested());
19853 ref_nested().clear();
19858 template<typename V> bool encode(size_t index, V& v) const
19860 if(index != type) {return false;} return v(ref_nested());
19870 E-RABs-ToBeModified-ModReqItem-Split-Bearer ::= SEQUENCE {
19872 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
19873 meNB-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
19874 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
19879 struct E_RABs_ToBeModified_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 3>
19881 static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-Split-Bearer";}
19882 using parent_t = asn::sequence<4, 0, true, 3>;
19883 struct e_RAB_ID_t : E_RAB_ID
19885 static constexpr const char* name() {return "e_RAB_ID_t";}
19886 using parent_t = E_RAB_ID;
19889 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19890 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19891 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
19893 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
19894 using parent_t = E_RAB_Level_QoS_Parameters;
19895 static constexpr bool optional = true;
19898 e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
19899 e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
19900 struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
19902 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
19903 using parent_t = GTPtunnelEndpoint;
19904 static constexpr bool optional = true;
19907 meNB_GTPtunnelEndpoint_t& set_meNB_GTPtunnelEndpoint() { meNB_GTPtunnelEndpoint.setpresent(true); return meNB_GTPtunnelEndpoint;}
19908 meNB_GTPtunnelEndpoint_t const* get_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint.is_valid() ? &meNB_GTPtunnelEndpoint : nullptr;}
19909 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>
19911 static constexpr const char* name() {return "iE_Extensions_t";}
19912 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>;
19913 static constexpr bool optional = true;
19916 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19917 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19918 template<typename V> void decode(V& v)
19921 v(e_RAB_Level_QoS_Parameters);
19922 v(meNB_GTPtunnelEndpoint);
19926 template<typename V> void encode(V& v) const
19929 v(e_RAB_Level_QoS_Parameters);
19930 v(meNB_GTPtunnelEndpoint);
19937 e_RAB_Level_QoS_Parameters.clear();
19938 meNB_GTPtunnelEndpoint.clear();
19939 iE_Extensions.clear();
19943 e_RAB_ID_t e_RAB_ID;
19944 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
19945 meNB_GTPtunnelEndpoint_t meNB_GTPtunnelEndpoint;
19946 iE_Extensions_t iE_Extensions;
19950 E-RABs-ToBeModified-ModReqItem ::= CHOICE {
19951 sCG-Bearer E-RABs-ToBeModified-ModReqItem-SCG-Bearer,
19952 split-Bearer E-RABs-ToBeModified-ModReqItem-Split-Bearer,
19957 struct E_RABs_ToBeModified_ModReqItem : asn::choice<2, 0, true>
19959 static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem";}
19960 using parent_t = asn::choice<2, 0, true>;
19961 index_type get_index() const {return index;}
19962 bool is_unknown() const {return index == 3;}
19963 void set_unknown() { set_index(3); }
19964 ~E_RABs_ToBeModified_ModReqItem() {clear();}
19965 struct sCG_Bearer_t : E_RABs_ToBeModified_ModReqItem_SCG_Bearer
19967 static constexpr const char* name() {return "sCG_Bearer_t";}
19968 using parent_t = E_RABs_ToBeModified_ModReqItem_SCG_Bearer;
19971 struct split_Bearer_t : E_RABs_ToBeModified_ModReqItem_Split_Bearer
19973 static constexpr const char* name() {return "split_Bearer_t";}
19974 using parent_t = E_RABs_ToBeModified_ModReqItem_Split_Bearer;
19979 switch(get_index())
19981 case 1: var.destroy<sCG_Bearer_t>(); break;
19982 case 2: var.destroy<split_Bearer_t>(); break;
19987 template<typename V> bool decode(size_t idx, V& v)
19992 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
19993 case 2: set_index(2); return v(var.build<split_Bearer_t>());
19998 template<typename V> bool encode(V& v) const
20000 switch(get_index())
20002 case 1: return v(var.as<sCG_Bearer_t>());
20003 case 2: return v(var.as<split_Bearer_t>());
20007 template<typename V> static inline void enumerate(V& v)
20009 v.template operator()<sCG_Bearer_t>(1);
20010 v.template operator()<split_Bearer_t>(2);
20013 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
20014 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
20015 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
20016 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
20018 void set_index(index_type i) {index = i; base::set();}
20021 char dummy1[sizeof(sCG_Bearer_t)];
20022 char dummy2[sizeof(split_Bearer_t)];
20025 asn::variant<sizeof(union_type)> var;
20026 index_type index {0};
20029 E-RABs-ToBeModified-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
20030 { ID id-E-RABs-ToBeModified-ModReqItem CRITICALITY ignore TYPE E-RABs-ToBeModified-ModReqItem PRESENCE mandatory},
20035 struct E_RABs_ToBeModified_ModReqItemIEs
20037 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
20039 size_t get_index() const {return type;}
20040 bool is_unknown() const { return type == 2; }
20041 void clear() {type = 0;}
20042 void select_id_E_RABs_ToBeModified_ModReqItem() { set(id_E_RABs_ToBeModified_ModReqItem); type=1;}
20043 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
20044 template<typename V> bool decode(V& v)
20047 if(!v(ref_nested())) return false;
20048 if(equal(id_E_RABs_ToBeModified_ModReqItem)) { type = 1; return true; }
20049 else { type = 2; return true;}
20053 template<typename V> bool encode(V& v) const
20055 return v(ref_nested());
20059 template<typename V> bool decode(size_t index, V& v)
20064 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_ModReqItem);} return false;
20065 case 2: type = 2; return v(ref_nested());
20066 ref_nested().clear();
20071 template<typename V> bool encode(size_t index, V& v) const
20073 if(index != type) {return false;} return v(ref_nested());
20080 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
20082 size_t get_index() const {return type;}
20083 bool is_unknown() const { return type == 2; }
20084 void clear() {type = 0;}
20085 void select_id_E_RABs_ToBeModified_ModReqItem() { set(ignore); type=1;}
20086 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
20087 template<typename V> bool decode(V& v)
20090 if(!v(ref_nested())) return false;
20091 if(equal(ignore)) { type = 1; return true; }
20092 else { type = 2; return true;}
20096 template<typename V> bool encode(V& v) const
20098 return v(ref_nested());
20102 template<typename V> bool decode(size_t index, V& v)
20107 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20108 case 2: type = 2; return v(ref_nested());
20109 ref_nested().clear();
20114 template<typename V> bool encode(size_t index, V& v) const
20116 if(index != type) {return false;} return v(ref_nested());
20123 struct Value_t : asn::typefield<true>
20125 ~Value_t() {clear();}
20126 size_t get_index() const {return type;}
20127 E_RABs_ToBeModified_ModReqItem& select_id_E_RABs_ToBeModified_ModReqItem() { return set<E_RABs_ToBeModified_ModReqItem>(1); }
20128 E_RABs_ToBeModified_ModReqItem const* get_id_E_RABs_ToBeModified_ModReqItem() const { return get<E_RABs_ToBeModified_ModReqItem>(1); }
20129 bool is_unknown() const { return type == 2; }
20134 case 1: var.destroy<E_RABs_ToBeModified_ModReqItem>(); break;
20136 type = 0; ref_nested().clear();
20138 template<typename V> static inline void enumerate(V& v)
20140 v.template operator()<E_RABs_ToBeModified_ModReqItem>(1);
20144 template<typename V> bool decode(size_t index, V& v)
20149 case 1: v(select_id_E_RABs_ToBeModified_ModReqItem()); return true;
20150 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
20155 template<typename V> bool encode(size_t index, V& v) const
20157 if(index != type) return false;
20160 case 1: v(var.as<E_RABs_ToBeModified_ModReqItem>()); return true;
20166 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20167 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20170 char dummy1[sizeof(E_RABs_ToBeModified_ModReqItem)];
20173 asn::variant<sizeof(union_type)> var;
20177 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
20179 size_t get_index() const {return type;}
20180 bool is_unknown() const { return type == 2; }
20181 void clear() {type = 0;}
20182 void select_id_E_RABs_ToBeModified_ModReqItem() { set(mandatory); type=1;}
20183 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
20184 template<typename V> bool decode(V& v)
20187 if(!v(ref_nested())) return false;
20188 if(equal(mandatory)) { type = 1; return true; }
20189 else { type = 2; return true;}
20193 template<typename V> bool encode(V& v) const
20195 return v(ref_nested());
20199 template<typename V> bool decode(size_t index, V& v)
20204 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
20205 case 2: type = 2; return v(ref_nested());
20206 ref_nested().clear();
20211 template<typename V> bool encode(size_t index, V& v) const
20213 if(index != type) {return false;} return v(ref_nested());
20223 E-RABs-ToBeModified-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-ModReqItemIEs} }
20226 struct E_RABs_ToBeModified_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>
20228 static constexpr const char* name() {return "E_RABs_ToBeModified_List_ModReq_elm";}
20229 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>;
20232 struct E_RABs_ToBeModified_List_ModReq : asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>
20234 static constexpr const char* name() {return "E-RABs-ToBeModified-List-ModReq";}
20235 using parent_t = asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>;
20236 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
20240 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20241 { ID id-RLC-Status CRITICALITY ignore EXTENSION RLC-Status PRESENCE optional },
20246 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs
20248 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20250 size_t get_index() const {return type;}
20251 bool is_unknown() const { return type == 2; }
20252 void clear() {type = 0;}
20253 void select_id_RLC_Status() { set(id_RLC_Status); type=1;}
20254 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20255 template<typename V> bool decode(V& v)
20258 if(!v(ref_nested())) return false;
20259 if(equal(id_RLC_Status)) { type = 1; return true; }
20260 else { type = 2; return true;}
20264 template<typename V> bool encode(V& v) const
20266 return v(ref_nested());
20270 template<typename V> bool decode(size_t index, V& v)
20275 case 1: type = 1; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
20276 case 2: type = 2; return v(ref_nested());
20277 ref_nested().clear();
20282 template<typename V> bool encode(size_t index, V& v) const
20284 if(index != type) {return false;} return v(ref_nested());
20291 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20293 size_t get_index() const {return type;}
20294 bool is_unknown() const { return type == 2; }
20295 void clear() {type = 0;}
20296 void select_id_RLC_Status() { set(ignore); type=1;}
20297 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20298 template<typename V> bool decode(V& v)
20301 if(!v(ref_nested())) return false;
20302 if(equal(ignore)) { type = 1; return true; }
20303 else { type = 2; return true;}
20307 template<typename V> bool encode(V& v) const
20309 return v(ref_nested());
20313 template<typename V> bool decode(size_t index, V& v)
20318 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20319 case 2: type = 2; return v(ref_nested());
20320 ref_nested().clear();
20325 template<typename V> bool encode(size_t index, V& v) const
20327 if(index != type) {return false;} return v(ref_nested());
20334 struct Extension_t : asn::typefield<true>
20336 ~Extension_t() {clear();}
20337 size_t get_index() const {return type;}
20338 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
20339 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
20340 bool is_unknown() const { return type == 2; }
20345 case 1: var.destroy<RLC_Status>(); break;
20347 type = 0; ref_nested().clear();
20349 template<typename V> static inline void enumerate(V& v)
20351 v.template operator()<RLC_Status>(1);
20355 template<typename V> bool decode(size_t index, V& v)
20360 case 1: v(select_id_RLC_Status()); return true;
20361 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
20366 template<typename V> bool encode(size_t index, V& v) const
20368 if(index != type) return false;
20371 case 1: v(var.as<RLC_Status>()); return true;
20377 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20378 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20381 char dummy1[sizeof(RLC_Status)];
20384 asn::variant<sizeof(union_type)> var;
20388 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20390 size_t get_index() const {return type;}
20391 bool is_unknown() const { return type == 2; }
20392 void clear() {type = 0;}
20393 void select_id_RLC_Status() { set(optional); type=1;}
20394 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20395 template<typename V> bool decode(V& v)
20398 if(!v(ref_nested())) return false;
20399 if(equal(optional)) { type = 1; return true; }
20400 else { type = 2; return true;}
20404 template<typename V> bool encode(V& v) const
20406 return v(ref_nested());
20410 template<typename V> bool decode(size_t index, V& v)
20415 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20416 case 2: type = 2; return v(ref_nested());
20417 ref_nested().clear();
20422 template<typename V> bool encode(size_t index, V& v) const
20424 if(index != type) {return false;} return v(ref_nested());
20434 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
20435 full-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
20436 max-MN-admit-E-RAB-Level-QoS-Parameters GBR-QosInformation OPTIONAL,
20437 meNB-DL-GTP-TEIDatMCG GTPtunnelEndpoint OPTIONAL,
20438 s1-UL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
20439 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
20444 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
20446 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent";}
20447 using parent_t = asn::sequence<5, 0, true, 5>;
20448 struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
20450 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
20451 using parent_t = E_RAB_Level_QoS_Parameters;
20452 static constexpr bool optional = true;
20455 full_E_RAB_Level_QoS_Parameters_t& set_full_E_RAB_Level_QoS_Parameters() { full_E_RAB_Level_QoS_Parameters.setpresent(true); return full_E_RAB_Level_QoS_Parameters;}
20456 full_E_RAB_Level_QoS_Parameters_t const* get_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters.is_valid() ? &full_E_RAB_Level_QoS_Parameters : nullptr;}
20457 struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
20459 static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
20460 using parent_t = GBR_QosInformation;
20461 static constexpr bool optional = true;
20464 max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
20465 max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
20466 struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
20468 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
20469 using parent_t = GTPtunnelEndpoint;
20470 static constexpr bool optional = true;
20473 meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
20474 meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
20475 struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
20477 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
20478 using parent_t = GTPtunnelEndpoint;
20479 static constexpr bool optional = true;
20482 s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
20483 s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
20484 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
20486 static constexpr const char* name() {return "iE_Extensions_t";}
20487 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
20488 static constexpr bool optional = true;
20491 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20492 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20493 template<typename V> void decode(V& v)
20495 v(full_E_RAB_Level_QoS_Parameters);
20496 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
20497 v(meNB_DL_GTP_TEIDatMCG);
20498 v(s1_UL_GTPtunnelEndpoint);
20502 template<typename V> void encode(V& v) const
20504 v(full_E_RAB_Level_QoS_Parameters);
20505 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
20506 v(meNB_DL_GTP_TEIDatMCG);
20507 v(s1_UL_GTPtunnelEndpoint);
20513 full_E_RAB_Level_QoS_Parameters.clear();
20514 max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
20515 meNB_DL_GTP_TEIDatMCG.clear();
20516 s1_UL_GTPtunnelEndpoint.clear();
20517 iE_Extensions.clear();
20521 full_E_RAB_Level_QoS_Parameters_t full_E_RAB_Level_QoS_Parameters;
20522 max_MN_admit_E_RAB_Level_QoS_Parameters_t max_MN_admit_E_RAB_Level_QoS_Parameters;
20523 meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
20524 s1_UL_GTPtunnelEndpoint_t s1_UL_GTPtunnelEndpoint;
20525 iE_Extensions_t iE_Extensions;
20529 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20530 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
20531 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
20532 { ID id-secondarymeNBULGTPTEIDatPDCP CRITICALITY ignore EXTENSION GTPtunnelEndpoint PRESENCE optional},
20537 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
20539 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20541 size_t get_index() const {return type;}
20542 bool is_unknown() const { return type == 4; }
20543 void clear() {type = 0;}
20544 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
20545 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
20546 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(id_secondarymeNBULGTPTEIDatPDCP); type=3;}
20547 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20548 template<typename V> bool decode(V& v)
20551 if(!v(ref_nested())) return false;
20552 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
20553 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
20554 else if(equal(id_secondarymeNBULGTPTEIDatPDCP)) { type = 3; return true; }
20555 else { type = 4; return true;}
20559 template<typename V> bool encode(V& v) const
20561 return v(ref_nested());
20565 template<typename V> bool decode(size_t index, V& v)
20570 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
20571 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
20572 case 3: type = 3; if(v(ref_nested())) { return equal(id_secondarymeNBULGTPTEIDatPDCP);} return false;
20573 case 4: type = 4; return v(ref_nested());
20574 ref_nested().clear();
20579 template<typename V> bool encode(size_t index, V& v) const
20581 if(index != type) {return false;} return v(ref_nested());
20588 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20590 size_t get_index() const {return type;}
20591 bool is_unknown() const { return type == 4; }
20592 void clear() {type = 0;}
20593 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
20594 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
20595 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(ignore); type=3;}
20596 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20597 template<typename V> bool decode(V& v)
20600 if(!v(ref_nested())) return false;
20601 if(equal(ignore)) { type = 1; return true; }
20602 else if(equal(ignore)) { type = 2; return true; }
20603 else if(equal(ignore)) { type = 3; return true; }
20604 else { type = 4; return true;}
20608 template<typename V> bool encode(V& v) const
20610 return v(ref_nested());
20614 template<typename V> bool decode(size_t index, V& v)
20619 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20620 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
20621 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
20622 case 4: type = 4; return v(ref_nested());
20623 ref_nested().clear();
20628 template<typename V> bool encode(size_t index, V& v) const
20630 if(index != type) {return false;} return v(ref_nested());
20637 struct Extension_t : asn::typefield<true>
20639 ~Extension_t() {clear();}
20640 size_t get_index() const {return type;}
20641 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
20642 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
20643 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
20644 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
20645 GTPtunnelEndpoint& select_id_secondarymeNBULGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(3); }
20646 GTPtunnelEndpoint const* get_id_secondarymeNBULGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(3); }
20647 bool is_unknown() const { return type == 4; }
20652 case 1: var.destroy<PDCPSnLength>(); break;
20653 case 2: var.destroy<PDCPSnLength>(); break;
20654 case 3: var.destroy<GTPtunnelEndpoint>(); break;
20656 type = 0; ref_nested().clear();
20658 template<typename V> static inline void enumerate(V& v)
20660 v.template operator()<PDCPSnLength>(1);
20661 v.template operator()<PDCPSnLength>(2);
20662 v.template operator()<GTPtunnelEndpoint>(3);
20666 template<typename V> bool decode(size_t index, V& v)
20671 case 1: v(select_id_uLpDCPSnLength()); return true;
20672 case 2: v(select_id_dLPDCPSnLength()); return true;
20673 case 3: v(select_id_secondarymeNBULGTPTEIDatPDCP()); return true;
20674 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
20679 template<typename V> bool encode(size_t index, V& v) const
20681 if(index != type) return false;
20684 case 1: v(var.as<PDCPSnLength>()); return true;
20685 case 2: v(var.as<PDCPSnLength>()); return true;
20686 case 3: v(var.as<GTPtunnelEndpoint>()); return true;
20692 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20693 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20696 char dummy1[sizeof(GTPtunnelEndpoint)];
20697 char dummy2[sizeof(PDCPSnLength)];
20700 asn::variant<sizeof(union_type)> var;
20704 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20706 size_t get_index() const {return type;}
20707 bool is_unknown() const { return type == 4; }
20708 void clear() {type = 0;}
20709 void select_id_uLpDCPSnLength() { set(optional); type=1;}
20710 void select_id_dLPDCPSnLength() { set(optional); type=2;}
20711 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(optional); type=3;}
20712 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20713 template<typename V> bool decode(V& v)
20716 if(!v(ref_nested())) return false;
20717 if(equal(optional)) { type = 1; return true; }
20718 else if(equal(optional)) { type = 2; return true; }
20719 else if(equal(optional)) { type = 3; return true; }
20720 else { type = 4; return true;}
20724 template<typename V> bool encode(V& v) const
20726 return v(ref_nested());
20730 template<typename V> bool decode(size_t index, V& v)
20735 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20736 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
20737 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
20738 case 4: type = 4; return v(ref_nested());
20739 ref_nested().clear();
20744 template<typename V> bool encode(size_t index, V& v) const
20746 if(index != type) {return false;} return v(ref_nested());
20756 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
20757 requested-SCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
20758 meNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
20759 uL-Configuration ULConfiguration OPTIONAL,
20760 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
20765 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<4, 0, true, 4>
20767 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent";}
20768 using parent_t = asn::sequence<4, 0, true, 4>;
20769 struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
20771 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
20772 using parent_t = E_RAB_Level_QoS_Parameters;
20773 static constexpr bool optional = true;
20776 requested_SCG_E_RAB_Level_QoS_Parameters_t& set_requested_SCG_E_RAB_Level_QoS_Parameters() { requested_SCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_SCG_E_RAB_Level_QoS_Parameters;}
20777 requested_SCG_E_RAB_Level_QoS_Parameters_t const* get_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_SCG_E_RAB_Level_QoS_Parameters : nullptr;}
20778 struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
20780 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
20781 using parent_t = GTPtunnelEndpoint;
20782 static constexpr bool optional = true;
20785 meNB_UL_GTP_TEIDatPDCP_t& set_meNB_UL_GTP_TEIDatPDCP() { meNB_UL_GTP_TEIDatPDCP.setpresent(true); return meNB_UL_GTP_TEIDatPDCP;}
20786 meNB_UL_GTP_TEIDatPDCP_t const* get_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP.is_valid() ? &meNB_UL_GTP_TEIDatPDCP : nullptr;}
20787 struct uL_Configuration_t : ULConfiguration
20789 static constexpr const char* name() {return "uL_Configuration_t";}
20790 using parent_t = ULConfiguration;
20791 static constexpr bool optional = true;
20794 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
20795 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
20796 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
20798 static constexpr const char* name() {return "iE_Extensions_t";}
20799 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
20800 static constexpr bool optional = true;
20803 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20804 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20805 template<typename V> void decode(V& v)
20807 v(requested_SCG_E_RAB_Level_QoS_Parameters);
20808 v(meNB_UL_GTP_TEIDatPDCP);
20809 v(uL_Configuration);
20813 template<typename V> void encode(V& v) const
20815 v(requested_SCG_E_RAB_Level_QoS_Parameters);
20816 v(meNB_UL_GTP_TEIDatPDCP);
20817 v(uL_Configuration);
20823 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
20824 meNB_UL_GTP_TEIDatPDCP.clear();
20825 uL_Configuration.clear();
20826 iE_Extensions.clear();
20830 requested_SCG_E_RAB_Level_QoS_Parameters_t requested_SCG_E_RAB_Level_QoS_Parameters;
20831 meNB_UL_GTP_TEIDatPDCP_t meNB_UL_GTP_TEIDatPDCP;
20832 uL_Configuration_t uL_Configuration;
20833 iE_Extensions_t iE_Extensions;
20837 E-RABs-ToBeModified-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20842 struct E_RABs_ToBeModified_SgNBModReq_ItemExtIEs
20844 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20846 size_t get_index() const {return type;}
20847 bool is_unknown() const { return type == 1; }
20848 void clear() {type = 0;}
20849 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20850 template<typename V> bool decode(V& v)
20853 if(!v(ref_nested())) return false;
20854 { type = 1; return true;}
20858 template<typename V> bool encode(V& v) const
20860 return v(ref_nested());
20864 template<typename V> bool decode(size_t index, V& v)
20869 case 1: type = 1; return v(ref_nested());
20870 ref_nested().clear();
20875 template<typename V> bool encode(size_t index, V& v) const
20877 if(index != type) {return false;} return v(ref_nested());
20884 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20886 size_t get_index() const {return type;}
20887 bool is_unknown() const { return type == 1; }
20888 void clear() {type = 0;}
20889 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20890 template<typename V> bool decode(V& v)
20893 if(!v(ref_nested())) return false;
20894 { type = 1; return true;}
20898 template<typename V> bool encode(V& v) const
20900 return v(ref_nested());
20904 template<typename V> bool decode(size_t index, V& v)
20909 case 1: type = 1; return v(ref_nested());
20910 ref_nested().clear();
20915 template<typename V> bool encode(size_t index, V& v) const
20917 if(index != type) {return false;} return v(ref_nested());
20924 struct Extension_t : asn::typefield<true>
20926 ~Extension_t() {clear();}
20927 size_t get_index() const {return type;}
20928 bool is_unknown() const { return type == 1; }
20931 type = 0; ref_nested().clear();
20933 template<typename V> static inline void enumerate(V& v)
20938 template<typename V> bool decode(size_t index, V& v)
20943 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20948 template<typename V> bool encode(size_t index, V& v) const
20950 if(index != type) return false;
20958 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20960 size_t get_index() const {return type;}
20961 bool is_unknown() const { return type == 1; }
20962 void clear() {type = 0;}
20963 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20964 template<typename V> bool decode(V& v)
20967 if(!v(ref_nested())) return false;
20968 { type = 1; return true;}
20972 template<typename V> bool encode(V& v) const
20974 return v(ref_nested());
20978 template<typename V> bool decode(size_t index, V& v)
20983 case 1: type = 1; return v(ref_nested());
20984 ref_nested().clear();
20989 template<typename V> bool encode(size_t index, V& v) const
20991 if(index != type) {return false;} return v(ref_nested());
21001 E-RABs-ToBeModified-SgNBModReq-Item ::= SEQUENCE {
21003 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
21004 resource-configuration CHOICE {
21005 sgNBPDCPpresent E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent,
21006 sgNBPDCPnotpresent E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent,
21009 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-ItemExtIEs} } OPTIONAL,
21014 struct E_RABs_ToBeModified_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
21016 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item";}
21017 using parent_t = asn::sequence<4, 0, true, 1>;
21018 struct e_RAB_ID_t : E_RAB_ID
21020 static constexpr const char* name() {return "e_RAB_ID_t";}
21021 using parent_t = E_RAB_ID;
21024 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
21025 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
21026 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
21028 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
21029 using parent_t = EN_DC_ResourceConfiguration;
21032 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
21033 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
21034 struct resource_configuration_t : asn::choice<2, 0, true>
21036 static constexpr const char* name() {return "resource_configuration_t";}
21037 using parent_t = asn::choice<2, 0, true>;
21038 index_type get_index() const {return index;}
21039 bool is_unknown() const {return index == 3;}
21040 void set_unknown() { set_index(3); }
21041 ~resource_configuration_t() {clear();}
21042 struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent
21044 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
21045 using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent;
21048 struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent
21050 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
21051 using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent;
21056 switch(get_index())
21058 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
21059 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
21064 template<typename V> bool decode(size_t idx, V& v)
21069 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
21070 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
21075 template<typename V> bool encode(V& v) const
21077 switch(get_index())
21079 case 1: return v(var.as<sgNBPDCPpresent_t>());
21080 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
21084 template<typename V> static inline void enumerate(V& v)
21086 v.template operator()<sgNBPDCPpresent_t>(1);
21087 v.template operator()<sgNBPDCPnotpresent_t>(2);
21090 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
21091 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
21092 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
21093 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
21095 void set_index(index_type i) {index = i; base::set();}
21098 char dummy1[sizeof(sgNBPDCPpresent_t)];
21099 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
21102 asn::variant<sizeof(union_type)> var;
21103 index_type index {0};
21105 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
21106 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
21107 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>
21109 static constexpr const char* name() {return "iE_Extensions_t";}
21110 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>;
21111 static constexpr bool optional = true;
21114 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21115 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21116 template<typename V> void decode(V& v)
21119 v(en_DC_ResourceConfiguration);
21120 v(resource_configuration);
21124 template<typename V> void encode(V& v) const
21127 v(en_DC_ResourceConfiguration);
21128 v(resource_configuration);
21135 en_DC_ResourceConfiguration.clear();
21136 resource_configuration.clear();
21137 iE_Extensions.clear();
21141 e_RAB_ID_t e_RAB_ID;
21142 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
21143 resource_configuration_t resource_configuration;
21144 iE_Extensions_t iE_Extensions;
21148 E-RABs-ToBeModified-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
21149 { ID id-E-RABs-ToBeModified-SgNBModReq-Item CRITICALITY ignore TYPE E-RABs-ToBeModified-SgNBModReq-Item PRESENCE mandatory},
21154 struct E_RABs_ToBeModified_SgNBModReq_ItemIEs
21156 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
21158 size_t get_index() const {return type;}
21159 bool is_unknown() const { return type == 2; }
21160 void clear() {type = 0;}
21161 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(id_E_RABs_ToBeModified_SgNBModReq_Item); type=1;}
21162 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
21163 template<typename V> bool decode(V& v)
21166 if(!v(ref_nested())) return false;
21167 if(equal(id_E_RABs_ToBeModified_SgNBModReq_Item)) { type = 1; return true; }
21168 else { type = 2; return true;}
21172 template<typename V> bool encode(V& v) const
21174 return v(ref_nested());
21178 template<typename V> bool decode(size_t index, V& v)
21183 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReq_Item);} return false;
21184 case 2: type = 2; return v(ref_nested());
21185 ref_nested().clear();
21190 template<typename V> bool encode(size_t index, V& v) const
21192 if(index != type) {return false;} return v(ref_nested());
21199 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
21201 size_t get_index() const {return type;}
21202 bool is_unknown() const { return type == 2; }
21203 void clear() {type = 0;}
21204 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(ignore); type=1;}
21205 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
21206 template<typename V> bool decode(V& v)
21209 if(!v(ref_nested())) return false;
21210 if(equal(ignore)) { type = 1; return true; }
21211 else { type = 2; return true;}
21215 template<typename V> bool encode(V& v) const
21217 return v(ref_nested());
21221 template<typename V> bool decode(size_t index, V& v)
21226 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21227 case 2: type = 2; return v(ref_nested());
21228 ref_nested().clear();
21233 template<typename V> bool encode(size_t index, V& v) const
21235 if(index != type) {return false;} return v(ref_nested());
21242 struct Value_t : asn::typefield<true>
21244 ~Value_t() {clear();}
21245 size_t get_index() const {return type;}
21246 E_RABs_ToBeModified_SgNBModReq_Item& select_id_E_RABs_ToBeModified_SgNBModReq_Item() { return set<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
21247 E_RABs_ToBeModified_SgNBModReq_Item const* get_id_E_RABs_ToBeModified_SgNBModReq_Item() const { return get<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
21248 bool is_unknown() const { return type == 2; }
21253 case 1: var.destroy<E_RABs_ToBeModified_SgNBModReq_Item>(); break;
21255 type = 0; ref_nested().clear();
21257 template<typename V> static inline void enumerate(V& v)
21259 v.template operator()<E_RABs_ToBeModified_SgNBModReq_Item>(1);
21263 template<typename V> bool decode(size_t index, V& v)
21268 case 1: v(select_id_E_RABs_ToBeModified_SgNBModReq_Item()); return true;
21269 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
21274 template<typename V> bool encode(size_t index, V& v) const
21276 if(index != type) return false;
21279 case 1: v(var.as<E_RABs_ToBeModified_SgNBModReq_Item>()); return true;
21285 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21286 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21289 char dummy1[sizeof(E_RABs_ToBeModified_SgNBModReq_Item)];
21292 asn::variant<sizeof(union_type)> var;
21296 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
21298 size_t get_index() const {return type;}
21299 bool is_unknown() const { return type == 2; }
21300 void clear() {type = 0;}
21301 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(mandatory); type=1;}
21302 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
21303 template<typename V> bool decode(V& v)
21306 if(!v(ref_nested())) return false;
21307 if(equal(mandatory)) { type = 1; return true; }
21308 else { type = 2; return true;}
21312 template<typename V> bool encode(V& v) const
21314 return v(ref_nested());
21318 template<typename V> bool decode(size_t index, V& v)
21323 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
21324 case 2: type = 2; return v(ref_nested());
21325 ref_nested().clear();
21330 template<typename V> bool encode(size_t index, V& v) const
21332 if(index != type) {return false;} return v(ref_nested());
21342 E-RABs-ToBeModified-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReq-ItemIEs} }
21345 struct E_RABs_ToBeModified_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>
21347 static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReq_List_elm";}
21348 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>;
21351 struct E_RABs_ToBeModified_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>
21353 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-List";}
21354 using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>;
21355 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
21359 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21360 { ID id-uLpDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
21361 { ID id-dLPDCPSnLength CRITICALITY ignore EXTENSION PDCPSnLength PRESENCE optional}|
21362 { ID id-new-drb-ID-req CRITICALITY ignore EXTENSION NewDRBIDrequest PRESENCE optional},
21367 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs
21369 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21371 size_t get_index() const {return type;}
21372 bool is_unknown() const { return type == 4; }
21373 void clear() {type = 0;}
21374 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
21375 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
21376 void select_id_new_drb_ID_req() { set(id_new_drb_ID_req); type=3;}
21377 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21378 template<typename V> bool decode(V& v)
21381 if(!v(ref_nested())) return false;
21382 if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
21383 else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
21384 else if(equal(id_new_drb_ID_req)) { type = 3; return true; }
21385 else { type = 4; return true;}
21389 template<typename V> bool encode(V& v) const
21391 return v(ref_nested());
21395 template<typename V> bool decode(size_t index, V& v)
21400 case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
21401 case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
21402 case 3: type = 3; if(v(ref_nested())) { return equal(id_new_drb_ID_req);} return false;
21403 case 4: type = 4; return v(ref_nested());
21404 ref_nested().clear();
21409 template<typename V> bool encode(size_t index, V& v) const
21411 if(index != type) {return false;} return v(ref_nested());
21418 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21420 size_t get_index() const {return type;}
21421 bool is_unknown() const { return type == 4; }
21422 void clear() {type = 0;}
21423 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
21424 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
21425 void select_id_new_drb_ID_req() { set(ignore); type=3;}
21426 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21427 template<typename V> bool decode(V& v)
21430 if(!v(ref_nested())) return false;
21431 if(equal(ignore)) { type = 1; return true; }
21432 else if(equal(ignore)) { type = 2; return true; }
21433 else if(equal(ignore)) { type = 3; return true; }
21434 else { type = 4; return true;}
21438 template<typename V> bool encode(V& v) const
21440 return v(ref_nested());
21444 template<typename V> bool decode(size_t index, V& v)
21449 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21450 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21451 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
21452 case 4: type = 4; return v(ref_nested());
21453 ref_nested().clear();
21458 template<typename V> bool encode(size_t index, V& v) const
21460 if(index != type) {return false;} return v(ref_nested());
21467 struct Extension_t : asn::typefield<true>
21469 ~Extension_t() {clear();}
21470 size_t get_index() const {return type;}
21471 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
21472 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
21473 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
21474 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
21475 NewDRBIDrequest& select_id_new_drb_ID_req() { return set<NewDRBIDrequest>(3); }
21476 NewDRBIDrequest const* get_id_new_drb_ID_req() const { return get<NewDRBIDrequest>(3); }
21477 bool is_unknown() const { return type == 4; }
21482 case 1: var.destroy<PDCPSnLength>(); break;
21483 case 2: var.destroy<PDCPSnLength>(); break;
21484 case 3: var.destroy<NewDRBIDrequest>(); break;
21486 type = 0; ref_nested().clear();
21488 template<typename V> static inline void enumerate(V& v)
21490 v.template operator()<PDCPSnLength>(1);
21491 v.template operator()<PDCPSnLength>(2);
21492 v.template operator()<NewDRBIDrequest>(3);
21496 template<typename V> bool decode(size_t index, V& v)
21501 case 1: v(select_id_uLpDCPSnLength()); return true;
21502 case 2: v(select_id_dLPDCPSnLength()); return true;
21503 case 3: v(select_id_new_drb_ID_req()); return true;
21504 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
21509 template<typename V> bool encode(size_t index, V& v) const
21511 if(index != type) return false;
21514 case 1: v(var.as<PDCPSnLength>()); return true;
21515 case 2: v(var.as<PDCPSnLength>()); return true;
21516 case 3: v(var.as<NewDRBIDrequest>()); return true;
21522 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21523 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21526 char dummy1[sizeof(NewDRBIDrequest)];
21527 char dummy2[sizeof(PDCPSnLength)];
21530 asn::variant<sizeof(union_type)> var;
21534 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21536 size_t get_index() const {return type;}
21537 bool is_unknown() const { return type == 4; }
21538 void clear() {type = 0;}
21539 void select_id_uLpDCPSnLength() { set(optional); type=1;}
21540 void select_id_dLPDCPSnLength() { set(optional); type=2;}
21541 void select_id_new_drb_ID_req() { set(optional); type=3;}
21542 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21543 template<typename V> bool decode(V& v)
21546 if(!v(ref_nested())) return false;
21547 if(equal(optional)) { type = 1; return true; }
21548 else if(equal(optional)) { type = 2; return true; }
21549 else if(equal(optional)) { type = 3; return true; }
21550 else { type = 4; return true;}
21554 template<typename V> bool encode(V& v) const
21556 return v(ref_nested());
21560 template<typename V> bool decode(size_t index, V& v)
21565 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21566 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21567 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
21568 case 4: type = 4; return v(ref_nested());
21569 ref_nested().clear();
21574 template<typename V> bool encode(size_t index, V& v) const
21576 if(index != type) {return false;} return v(ref_nested());
21586 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent ::= SEQUENCE {
21587 requested-MCG-E-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters OPTIONAL,
21588 uL-Configuration ULConfiguration OPTIONAL,
21589 sgNB-UL-GTP-TEIDatPDCP GTPtunnelEndpoint OPTIONAL,
21590 s1-DL-GTP-TEIDatSgNB GTPtunnelEndpoint OPTIONAL,
21591 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
21596 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
21598 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent";}
21599 using parent_t = asn::sequence<5, 0, true, 5>;
21600 struct requested_MCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
21602 static constexpr const char* name() {return "requested_MCG_E_RAB_Level_QoS_Parameters_t";}
21603 using parent_t = E_RAB_Level_QoS_Parameters;
21604 static constexpr bool optional = true;
21607 requested_MCG_E_RAB_Level_QoS_Parameters_t& set_requested_MCG_E_RAB_Level_QoS_Parameters() { requested_MCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_MCG_E_RAB_Level_QoS_Parameters;}
21608 requested_MCG_E_RAB_Level_QoS_Parameters_t const* get_requested_MCG_E_RAB_Level_QoS_Parameters() const {return requested_MCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_MCG_E_RAB_Level_QoS_Parameters : nullptr;}
21609 struct uL_Configuration_t : ULConfiguration
21611 static constexpr const char* name() {return "uL_Configuration_t";}
21612 using parent_t = ULConfiguration;
21613 static constexpr bool optional = true;
21616 uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
21617 uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
21618 struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
21620 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
21621 using parent_t = GTPtunnelEndpoint;
21622 static constexpr bool optional = true;
21625 sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
21626 sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
21627 struct s1_DL_GTP_TEIDatSgNB_t : GTPtunnelEndpoint
21629 static constexpr const char* name() {return "s1_DL_GTP_TEIDatSgNB_t";}
21630 using parent_t = GTPtunnelEndpoint;
21631 static constexpr bool optional = true;
21634 s1_DL_GTP_TEIDatSgNB_t& set_s1_DL_GTP_TEIDatSgNB() { s1_DL_GTP_TEIDatSgNB.setpresent(true); return s1_DL_GTP_TEIDatSgNB;}
21635 s1_DL_GTP_TEIDatSgNB_t const* get_s1_DL_GTP_TEIDatSgNB() const {return s1_DL_GTP_TEIDatSgNB.is_valid() ? &s1_DL_GTP_TEIDatSgNB : nullptr;}
21636 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>
21638 static constexpr const char* name() {return "iE_Extensions_t";}
21639 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>;
21640 static constexpr bool optional = true;
21643 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21644 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21645 template<typename V> void decode(V& v)
21647 v(requested_MCG_E_RAB_Level_QoS_Parameters);
21648 v(uL_Configuration);
21649 v(sgNB_UL_GTP_TEIDatPDCP);
21650 v(s1_DL_GTP_TEIDatSgNB);
21654 template<typename V> void encode(V& v) const
21656 v(requested_MCG_E_RAB_Level_QoS_Parameters);
21657 v(uL_Configuration);
21658 v(sgNB_UL_GTP_TEIDatPDCP);
21659 v(s1_DL_GTP_TEIDatSgNB);
21665 requested_MCG_E_RAB_Level_QoS_Parameters.clear();
21666 uL_Configuration.clear();
21667 sgNB_UL_GTP_TEIDatPDCP.clear();
21668 s1_DL_GTP_TEIDatSgNB.clear();
21669 iE_Extensions.clear();
21673 requested_MCG_E_RAB_Level_QoS_Parameters_t requested_MCG_E_RAB_Level_QoS_Parameters;
21674 uL_Configuration_t uL_Configuration;
21675 sgNB_UL_GTP_TEIDatPDCP_t sgNB_UL_GTP_TEIDatPDCP;
21676 s1_DL_GTP_TEIDatSgNB_t s1_DL_GTP_TEIDatSgNB;
21677 iE_Extensions_t iE_Extensions;
21681 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21682 { ID id-RLC-Status CRITICALITY ignore EXTENSION RLC-Status PRESENCE optional}|
21683 { ID id-lCID CRITICALITY ignore EXTENSION LCID PRESENCE optional},
21688 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs
21690 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21692 size_t get_index() const {return type;}
21693 bool is_unknown() const { return type == 3; }
21694 void clear() {type = 0;}
21695 void select_id_RLC_Status() { set(id_RLC_Status); type=1;}
21696 void select_id_lCID() { set(id_lCID); type=2;}
21697 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21698 template<typename V> bool decode(V& v)
21701 if(!v(ref_nested())) return false;
21702 if(equal(id_RLC_Status)) { type = 1; return true; }
21703 else if(equal(id_lCID)) { type = 2; return true; }
21704 else { type = 3; return true;}
21708 template<typename V> bool encode(V& v) const
21710 return v(ref_nested());
21714 template<typename V> bool decode(size_t index, V& v)
21719 case 1: type = 1; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
21720 case 2: type = 2; if(v(ref_nested())) { return equal(id_lCID);} return false;
21721 case 3: type = 3; return v(ref_nested());
21722 ref_nested().clear();
21727 template<typename V> bool encode(size_t index, V& v) const
21729 if(index != type) {return false;} return v(ref_nested());
21736 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21738 size_t get_index() const {return type;}
21739 bool is_unknown() const { return type == 3; }
21740 void clear() {type = 0;}
21741 void select_id_RLC_Status() { set(ignore); type=1;}
21742 void select_id_lCID() { set(ignore); type=2;}
21743 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21744 template<typename V> bool decode(V& v)
21747 if(!v(ref_nested())) return false;
21748 if(equal(ignore)) { type = 1; return true; }
21749 else if(equal(ignore)) { type = 2; return true; }
21750 else { type = 3; return true;}
21754 template<typename V> bool encode(V& v) const
21756 return v(ref_nested());
21760 template<typename V> bool decode(size_t index, V& v)
21765 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21766 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21767 case 3: type = 3; return v(ref_nested());
21768 ref_nested().clear();
21773 template<typename V> bool encode(size_t index, V& v) const
21775 if(index != type) {return false;} return v(ref_nested());
21782 struct Extension_t : asn::typefield<true>
21784 ~Extension_t() {clear();}
21785 size_t get_index() const {return type;}
21786 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
21787 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
21788 LCID& select_id_lCID() { return set<LCID>(2); }
21789 LCID const* get_id_lCID() const { return get<LCID>(2); }
21790 bool is_unknown() const { return type == 3; }
21795 case 1: var.destroy<RLC_Status>(); break;
21796 case 2: var.destroy<LCID>(); break;
21798 type = 0; ref_nested().clear();
21800 template<typename V> static inline void enumerate(V& v)
21802 v.template operator()<RLC_Status>(1);
21803 v.template operator()<LCID>(2);
21807 template<typename V> bool decode(size_t index, V& v)
21812 case 1: v(select_id_RLC_Status()); return true;
21813 case 2: v(select_id_lCID()); return true;
21814 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
21819 template<typename V> bool encode(size_t index, V& v) const
21821 if(index != type) return false;
21824 case 1: v(var.as<RLC_Status>()); return true;
21825 case 2: v(var.as<LCID>()); return true;
21831 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21832 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21835 char dummy1[sizeof(LCID)];
21836 char dummy2[sizeof(RLC_Status)];
21839 asn::variant<sizeof(union_type)> var;
21843 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21845 size_t get_index() const {return type;}
21846 bool is_unknown() const { return type == 3; }
21847 void clear() {type = 0;}
21848 void select_id_RLC_Status() { set(optional); type=1;}
21849 void select_id_lCID() { set(optional); type=2;}
21850 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21851 template<typename V> bool decode(V& v)
21854 if(!v(ref_nested())) return false;
21855 if(equal(optional)) { type = 1; return true; }
21856 else if(equal(optional)) { type = 2; return true; }
21857 else { type = 3; return true;}
21861 template<typename V> bool encode(V& v) const
21863 return v(ref_nested());
21867 template<typename V> bool decode(size_t index, V& v)
21872 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21873 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21874 case 3: type = 3; return v(ref_nested());
21875 ref_nested().clear();
21880 template<typename V> bool encode(size_t index, V& v) const
21882 if(index != type) {return false;} return v(ref_nested());
21892 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent ::= SEQUENCE {
21893 sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint OPTIONAL,
21894 secondary-sgNB-DL-GTP-TEIDatSCG GTPtunnelEndpoint OPTIONAL,
21895 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
21900 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 3>
21902 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent";}
21903 using parent_t = asn::sequence<3, 0, true, 3>;
21904 struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
21906 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
21907 using parent_t = GTPtunnelEndpoint;
21908 static constexpr bool optional = true;
21911 sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
21912 sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
21913 struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
21915 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
21916 using parent_t = GTPtunnelEndpoint;
21917 static constexpr bool optional = true;
21920 secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
21921 secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
21922 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>
21924 static constexpr const char* name() {return "iE_Extensions_t";}
21925 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>;
21926 static constexpr bool optional = true;
21929 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21930 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21931 template<typename V> void decode(V& v)
21933 v(sgNB_DL_GTP_TEIDatSCG);
21934 v(secondary_sgNB_DL_GTP_TEIDatSCG);
21938 template<typename V> void encode(V& v) const
21940 v(sgNB_DL_GTP_TEIDatSCG);
21941 v(secondary_sgNB_DL_GTP_TEIDatSCG);
21947 sgNB_DL_GTP_TEIDatSCG.clear();
21948 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
21949 iE_Extensions.clear();
21953 sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
21954 secondary_sgNB_DL_GTP_TEIDatSCG_t secondary_sgNB_DL_GTP_TEIDatSCG;
21955 iE_Extensions_t iE_Extensions;
21959 E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21964 struct E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs
21966 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21968 size_t get_index() const {return type;}
21969 bool is_unknown() const { return type == 1; }
21970 void clear() {type = 0;}
21971 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21972 template<typename V> bool decode(V& v)
21975 if(!v(ref_nested())) return false;
21976 { type = 1; return true;}
21980 template<typename V> bool encode(V& v) const
21982 return v(ref_nested());
21986 template<typename V> bool decode(size_t index, V& v)
21991 case 1: type = 1; return v(ref_nested());
21992 ref_nested().clear();
21997 template<typename V> bool encode(size_t index, V& v) const
21999 if(index != type) {return false;} return v(ref_nested());
22006 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22008 size_t get_index() const {return type;}
22009 bool is_unknown() const { return type == 1; }
22010 void clear() {type = 0;}
22011 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22012 template<typename V> bool decode(V& v)
22015 if(!v(ref_nested())) return false;
22016 { type = 1; return true;}
22020 template<typename V> bool encode(V& v) const
22022 return v(ref_nested());
22026 template<typename V> bool decode(size_t index, V& v)
22031 case 1: type = 1; return v(ref_nested());
22032 ref_nested().clear();
22037 template<typename V> bool encode(size_t index, V& v) const
22039 if(index != type) {return false;} return v(ref_nested());
22046 struct Extension_t : asn::typefield<true>
22048 ~Extension_t() {clear();}
22049 size_t get_index() const {return type;}
22050 bool is_unknown() const { return type == 1; }
22053 type = 0; ref_nested().clear();
22055 template<typename V> static inline void enumerate(V& v)
22060 template<typename V> bool decode(size_t index, V& v)
22065 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22070 template<typename V> bool encode(size_t index, V& v) const
22072 if(index != type) return false;
22080 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22082 size_t get_index() const {return type;}
22083 bool is_unknown() const { return type == 1; }
22084 void clear() {type = 0;}
22085 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22086 template<typename V> bool decode(V& v)
22089 if(!v(ref_nested())) return false;
22090 { type = 1; return true;}
22094 template<typename V> bool encode(V& v) const
22096 return v(ref_nested());
22100 template<typename V> bool decode(size_t index, V& v)
22105 case 1: type = 1; return v(ref_nested());
22106 ref_nested().clear();
22111 template<typename V> bool encode(size_t index, V& v) const
22113 if(index != type) {return false;} return v(ref_nested());
22123 E-RABs-ToBeModified-SgNBModReqd-Item ::= SEQUENCE {
22125 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
22126 resource-configuration CHOICE {
22127 sgNBPDCPpresent E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent,
22128 sgNBPDCPnotpresent E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent,
22131 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs} } OPTIONAL,
22136 struct E_RABs_ToBeModified_SgNBModReqd_Item : asn::sequence<4, 0, true, 1>
22138 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item";}
22139 using parent_t = asn::sequence<4, 0, true, 1>;
22140 struct e_RAB_ID_t : E_RAB_ID
22142 static constexpr const char* name() {return "e_RAB_ID_t";}
22143 using parent_t = E_RAB_ID;
22146 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22147 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22148 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
22150 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
22151 using parent_t = EN_DC_ResourceConfiguration;
22154 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
22155 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
22156 struct resource_configuration_t : asn::choice<2, 0, true>
22158 static constexpr const char* name() {return "resource_configuration_t";}
22159 using parent_t = asn::choice<2, 0, true>;
22160 index_type get_index() const {return index;}
22161 bool is_unknown() const {return index == 3;}
22162 void set_unknown() { set_index(3); }
22163 ~resource_configuration_t() {clear();}
22164 struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent
22166 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
22167 using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent;
22170 struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent
22172 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
22173 using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent;
22178 switch(get_index())
22180 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
22181 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
22186 template<typename V> bool decode(size_t idx, V& v)
22191 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
22192 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
22197 template<typename V> bool encode(V& v) const
22199 switch(get_index())
22201 case 1: return v(var.as<sgNBPDCPpresent_t>());
22202 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
22206 template<typename V> static inline void enumerate(V& v)
22208 v.template operator()<sgNBPDCPpresent_t>(1);
22209 v.template operator()<sgNBPDCPnotpresent_t>(2);
22212 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
22213 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
22214 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
22215 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
22217 void set_index(index_type i) {index = i; base::set();}
22220 char dummy1[sizeof(sgNBPDCPpresent_t)];
22221 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
22224 asn::variant<sizeof(union_type)> var;
22225 index_type index {0};
22227 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
22228 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
22229 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>
22231 static constexpr const char* name() {return "iE_Extensions_t";}
22232 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>;
22233 static constexpr bool optional = true;
22236 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22237 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22238 template<typename V> void decode(V& v)
22241 v(en_DC_ResourceConfiguration);
22242 v(resource_configuration);
22246 template<typename V> void encode(V& v) const
22249 v(en_DC_ResourceConfiguration);
22250 v(resource_configuration);
22257 en_DC_ResourceConfiguration.clear();
22258 resource_configuration.clear();
22259 iE_Extensions.clear();
22263 e_RAB_ID_t e_RAB_ID;
22264 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
22265 resource_configuration_t resource_configuration;
22266 iE_Extensions_t iE_Extensions;
22270 E-RABs-ToBeModified-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
22271 { ID id-E-RABs-ToBeModified-SgNBModReqd-Item CRITICALITY ignore TYPE E-RABs-ToBeModified-SgNBModReqd-Item PRESENCE mandatory },
22276 struct E_RABs_ToBeModified_SgNBModReqd_ItemIEs
22278 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
22280 size_t get_index() const {return type;}
22281 bool is_unknown() const { return type == 2; }
22282 void clear() {type = 0;}
22283 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(id_E_RABs_ToBeModified_SgNBModReqd_Item); type=1;}
22284 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
22285 template<typename V> bool decode(V& v)
22288 if(!v(ref_nested())) return false;
22289 if(equal(id_E_RABs_ToBeModified_SgNBModReqd_Item)) { type = 1; return true; }
22290 else { type = 2; return true;}
22294 template<typename V> bool encode(V& v) const
22296 return v(ref_nested());
22300 template<typename V> bool decode(size_t index, V& v)
22305 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReqd_Item);} return false;
22306 case 2: type = 2; return v(ref_nested());
22307 ref_nested().clear();
22312 template<typename V> bool encode(size_t index, V& v) const
22314 if(index != type) {return false;} return v(ref_nested());
22321 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
22323 size_t get_index() const {return type;}
22324 bool is_unknown() const { return type == 2; }
22325 void clear() {type = 0;}
22326 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(ignore); type=1;}
22327 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
22328 template<typename V> bool decode(V& v)
22331 if(!v(ref_nested())) return false;
22332 if(equal(ignore)) { type = 1; return true; }
22333 else { type = 2; return true;}
22337 template<typename V> bool encode(V& v) const
22339 return v(ref_nested());
22343 template<typename V> bool decode(size_t index, V& v)
22348 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
22349 case 2: type = 2; return v(ref_nested());
22350 ref_nested().clear();
22355 template<typename V> bool encode(size_t index, V& v) const
22357 if(index != type) {return false;} return v(ref_nested());
22364 struct Value_t : asn::typefield<true>
22366 ~Value_t() {clear();}
22367 size_t get_index() const {return type;}
22368 E_RABs_ToBeModified_SgNBModReqd_Item& select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { return set<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
22369 E_RABs_ToBeModified_SgNBModReqd_Item const* get_id_E_RABs_ToBeModified_SgNBModReqd_Item() const { return get<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
22370 bool is_unknown() const { return type == 2; }
22375 case 1: var.destroy<E_RABs_ToBeModified_SgNBModReqd_Item>(); break;
22377 type = 0; ref_nested().clear();
22379 template<typename V> static inline void enumerate(V& v)
22381 v.template operator()<E_RABs_ToBeModified_SgNBModReqd_Item>(1);
22385 template<typename V> bool decode(size_t index, V& v)
22390 case 1: v(select_id_E_RABs_ToBeModified_SgNBModReqd_Item()); return true;
22391 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
22396 template<typename V> bool encode(size_t index, V& v) const
22398 if(index != type) return false;
22401 case 1: v(var.as<E_RABs_ToBeModified_SgNBModReqd_Item>()); return true;
22407 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
22408 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
22411 char dummy1[sizeof(E_RABs_ToBeModified_SgNBModReqd_Item)];
22414 asn::variant<sizeof(union_type)> var;
22418 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
22420 size_t get_index() const {return type;}
22421 bool is_unknown() const { return type == 2; }
22422 void clear() {type = 0;}
22423 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(mandatory); type=1;}
22424 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
22425 template<typename V> bool decode(V& v)
22428 if(!v(ref_nested())) return false;
22429 if(equal(mandatory)) { type = 1; return true; }
22430 else { type = 2; return true;}
22434 template<typename V> bool encode(V& v) const
22436 return v(ref_nested());
22440 template<typename V> bool decode(size_t index, V& v)
22445 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
22446 case 2: type = 2; return v(ref_nested());
22447 ref_nested().clear();
22452 template<typename V> bool encode(size_t index, V& v) const
22454 if(index != type) {return false;} return v(ref_nested());
22464 E-RABs-ToBeModified-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReqd-ItemIEs} }
22467 struct E_RABs_ToBeModified_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>
22469 static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReqdList_elm";}
22470 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>;
22473 struct E_RABs_ToBeModified_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>
22475 static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqdList";}
22476 using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>;
22477 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
22481 E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22486 struct E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs
22488 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22490 size_t get_index() const {return type;}
22491 bool is_unknown() const { return type == 1; }
22492 void clear() {type = 0;}
22493 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22494 template<typename V> bool decode(V& v)
22497 if(!v(ref_nested())) return false;
22498 { type = 1; return true;}
22502 template<typename V> bool encode(V& v) const
22504 return v(ref_nested());
22508 template<typename V> bool decode(size_t index, V& v)
22513 case 1: type = 1; return v(ref_nested());
22514 ref_nested().clear();
22519 template<typename V> bool encode(size_t index, V& v) const
22521 if(index != type) {return false;} return v(ref_nested());
22528 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22530 size_t get_index() const {return type;}
22531 bool is_unknown() const { return type == 1; }
22532 void clear() {type = 0;}
22533 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22534 template<typename V> bool decode(V& v)
22537 if(!v(ref_nested())) return false;
22538 { type = 1; return true;}
22542 template<typename V> bool encode(V& v) const
22544 return v(ref_nested());
22548 template<typename V> bool decode(size_t index, V& v)
22553 case 1: type = 1; return v(ref_nested());
22554 ref_nested().clear();
22559 template<typename V> bool encode(size_t index, V& v) const
22561 if(index != type) {return false;} return v(ref_nested());
22568 struct Extension_t : asn::typefield<true>
22570 ~Extension_t() {clear();}
22571 size_t get_index() const {return type;}
22572 bool is_unknown() const { return type == 1; }
22575 type = 0; ref_nested().clear();
22577 template<typename V> static inline void enumerate(V& v)
22582 template<typename V> bool decode(size_t index, V& v)
22587 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22592 template<typename V> bool encode(size_t index, V& v) const
22594 if(index != type) return false;
22602 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22604 size_t get_index() const {return type;}
22605 bool is_unknown() const { return type == 1; }
22606 void clear() {type = 0;}
22607 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22608 template<typename V> bool decode(V& v)
22611 if(!v(ref_nested())) return false;
22612 { type = 1; return true;}
22616 template<typename V> bool encode(V& v) const
22618 return v(ref_nested());
22622 template<typename V> bool decode(size_t index, V& v)
22627 case 1: type = 1; return v(ref_nested());
22628 ref_nested().clear();
22633 template<typename V> bool encode(size_t index, V& v) const
22635 if(index != type) {return false;} return v(ref_nested());
22645 E-RABs-ToBeReleased-ModReqItem-SCG-Bearer ::= SEQUENCE {
22647 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
22648 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
22649 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
22654 struct E_RABs_ToBeReleased_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
22656 static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-SCG-Bearer";}
22657 using parent_t = asn::sequence<4, 0, true, 3>;
22658 struct e_RAB_ID_t : E_RAB_ID
22660 static constexpr const char* name() {return "e_RAB_ID_t";}
22661 using parent_t = E_RAB_ID;
22664 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22665 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22666 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22668 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
22669 using parent_t = GTPtunnelEndpoint;
22670 static constexpr bool optional = true;
22673 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
22674 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
22675 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22677 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
22678 using parent_t = GTPtunnelEndpoint;
22679 static constexpr bool optional = true;
22682 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
22683 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
22684 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>
22686 static constexpr const char* name() {return "iE_Extensions_t";}
22687 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>;
22688 static constexpr bool optional = true;
22691 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22692 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22693 template<typename V> void decode(V& v)
22696 v(dL_Forwarding_GTPtunnelEndpoint);
22697 v(uL_Forwarding_GTPtunnelEndpoint);
22701 template<typename V> void encode(V& v) const
22704 v(dL_Forwarding_GTPtunnelEndpoint);
22705 v(uL_Forwarding_GTPtunnelEndpoint);
22712 dL_Forwarding_GTPtunnelEndpoint.clear();
22713 uL_Forwarding_GTPtunnelEndpoint.clear();
22714 iE_Extensions.clear();
22718 e_RAB_ID_t e_RAB_ID;
22719 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
22720 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
22721 iE_Extensions_t iE_Extensions;
22725 E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22730 struct E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs
22732 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22734 size_t get_index() const {return type;}
22735 bool is_unknown() const { return type == 1; }
22736 void clear() {type = 0;}
22737 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22738 template<typename V> bool decode(V& v)
22741 if(!v(ref_nested())) return false;
22742 { type = 1; return true;}
22746 template<typename V> bool encode(V& v) const
22748 return v(ref_nested());
22752 template<typename V> bool decode(size_t index, V& v)
22757 case 1: type = 1; return v(ref_nested());
22758 ref_nested().clear();
22763 template<typename V> bool encode(size_t index, V& v) const
22765 if(index != type) {return false;} return v(ref_nested());
22772 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22774 size_t get_index() const {return type;}
22775 bool is_unknown() const { return type == 1; }
22776 void clear() {type = 0;}
22777 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22778 template<typename V> bool decode(V& v)
22781 if(!v(ref_nested())) return false;
22782 { type = 1; return true;}
22786 template<typename V> bool encode(V& v) const
22788 return v(ref_nested());
22792 template<typename V> bool decode(size_t index, V& v)
22797 case 1: type = 1; return v(ref_nested());
22798 ref_nested().clear();
22803 template<typename V> bool encode(size_t index, V& v) const
22805 if(index != type) {return false;} return v(ref_nested());
22812 struct Extension_t : asn::typefield<true>
22814 ~Extension_t() {clear();}
22815 size_t get_index() const {return type;}
22816 bool is_unknown() const { return type == 1; }
22819 type = 0; ref_nested().clear();
22821 template<typename V> static inline void enumerate(V& v)
22826 template<typename V> bool decode(size_t index, V& v)
22831 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22836 template<typename V> bool encode(size_t index, V& v) const
22838 if(index != type) return false;
22846 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22848 size_t get_index() const {return type;}
22849 bool is_unknown() const { return type == 1; }
22850 void clear() {type = 0;}
22851 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22852 template<typename V> bool decode(V& v)
22855 if(!v(ref_nested())) return false;
22856 { type = 1; return true;}
22860 template<typename V> bool encode(V& v) const
22862 return v(ref_nested());
22866 template<typename V> bool decode(size_t index, V& v)
22871 case 1: type = 1; return v(ref_nested());
22872 ref_nested().clear();
22877 template<typename V> bool encode(size_t index, V& v) const
22879 if(index != type) {return false;} return v(ref_nested());
22889 E-RABs-ToBeReleased-ModReqItem-Split-Bearer ::= SEQUENCE {
22891 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
22892 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
22897 struct E_RABs_ToBeReleased_ModReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
22899 static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-Split-Bearer";}
22900 using parent_t = asn::sequence<3, 0, true, 2>;
22901 struct e_RAB_ID_t : E_RAB_ID
22903 static constexpr const char* name() {return "e_RAB_ID_t";}
22904 using parent_t = E_RAB_ID;
22907 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22908 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22909 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22911 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
22912 using parent_t = GTPtunnelEndpoint;
22913 static constexpr bool optional = true;
22916 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
22917 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
22918 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>
22920 static constexpr const char* name() {return "iE_Extensions_t";}
22921 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>;
22922 static constexpr bool optional = true;
22925 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22926 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22927 template<typename V> void decode(V& v)
22930 v(dL_Forwarding_GTPtunnelEndpoint);
22934 template<typename V> void encode(V& v) const
22937 v(dL_Forwarding_GTPtunnelEndpoint);
22944 dL_Forwarding_GTPtunnelEndpoint.clear();
22945 iE_Extensions.clear();
22949 e_RAB_ID_t e_RAB_ID;
22950 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
22951 iE_Extensions_t iE_Extensions;
22955 E-RABs-ToBeReleased-ModReqItem ::= CHOICE {
22956 sCG-Bearer E-RABs-ToBeReleased-ModReqItem-SCG-Bearer,
22957 split-Bearer E-RABs-ToBeReleased-ModReqItem-Split-Bearer,
22962 struct E_RABs_ToBeReleased_ModReqItem : asn::choice<2, 0, true>
22964 static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem";}
22965 using parent_t = asn::choice<2, 0, true>;
22966 index_type get_index() const {return index;}
22967 bool is_unknown() const {return index == 3;}
22968 void set_unknown() { set_index(3); }
22969 ~E_RABs_ToBeReleased_ModReqItem() {clear();}
22970 struct sCG_Bearer_t : E_RABs_ToBeReleased_ModReqItem_SCG_Bearer
22972 static constexpr const char* name() {return "sCG_Bearer_t";}
22973 using parent_t = E_RABs_ToBeReleased_ModReqItem_SCG_Bearer;
22976 struct split_Bearer_t : E_RABs_ToBeReleased_ModReqItem_Split_Bearer
22978 static constexpr const char* name() {return "split_Bearer_t";}
22979 using parent_t = E_RABs_ToBeReleased_ModReqItem_Split_Bearer;
22984 switch(get_index())
22986 case 1: var.destroy<sCG_Bearer_t>(); break;
22987 case 2: var.destroy<split_Bearer_t>(); break;
22992 template<typename V> bool decode(size_t idx, V& v)
22997 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
22998 case 2: set_index(2); return v(var.build<split_Bearer_t>());
23003 template<typename V> bool encode(V& v) const
23005 switch(get_index())
23007 case 1: return v(var.as<sCG_Bearer_t>());
23008 case 2: return v(var.as<split_Bearer_t>());
23012 template<typename V> static inline void enumerate(V& v)
23014 v.template operator()<sCG_Bearer_t>(1);
23015 v.template operator()<split_Bearer_t>(2);
23018 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
23019 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
23020 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
23021 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
23023 void set_index(index_type i) {index = i; base::set();}
23026 char dummy1[sizeof(sCG_Bearer_t)];
23027 char dummy2[sizeof(split_Bearer_t)];
23030 asn::variant<sizeof(union_type)> var;
23031 index_type index {0};
23034 E-RABs-ToBeReleased-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
23035 { ID id-E-RABs-ToBeReleased-ModReqItem CRITICALITY ignore TYPE E-RABs-ToBeReleased-ModReqItem PRESENCE mandatory},
23040 struct E_RABs_ToBeReleased_ModReqItemIEs
23042 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
23044 size_t get_index() const {return type;}
23045 bool is_unknown() const { return type == 2; }
23046 void clear() {type = 0;}
23047 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(id_E_RABs_ToBeReleased_ModReqItem); type=1;}
23048 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
23049 template<typename V> bool decode(V& v)
23052 if(!v(ref_nested())) return false;
23053 if(equal(id_E_RABs_ToBeReleased_ModReqItem)) { type = 1; return true; }
23054 else { type = 2; return true;}
23058 template<typename V> bool encode(V& v) const
23060 return v(ref_nested());
23064 template<typename V> bool decode(size_t index, V& v)
23069 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqItem);} return false;
23070 case 2: type = 2; return v(ref_nested());
23071 ref_nested().clear();
23076 template<typename V> bool encode(size_t index, V& v) const
23078 if(index != type) {return false;} return v(ref_nested());
23085 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
23087 size_t get_index() const {return type;}
23088 bool is_unknown() const { return type == 2; }
23089 void clear() {type = 0;}
23090 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(ignore); type=1;}
23091 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
23092 template<typename V> bool decode(V& v)
23095 if(!v(ref_nested())) return false;
23096 if(equal(ignore)) { type = 1; return true; }
23097 else { type = 2; return true;}
23101 template<typename V> bool encode(V& v) const
23103 return v(ref_nested());
23107 template<typename V> bool decode(size_t index, V& v)
23112 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
23113 case 2: type = 2; return v(ref_nested());
23114 ref_nested().clear();
23119 template<typename V> bool encode(size_t index, V& v) const
23121 if(index != type) {return false;} return v(ref_nested());
23128 struct Value_t : asn::typefield<true>
23130 ~Value_t() {clear();}
23131 size_t get_index() const {return type;}
23132 E_RABs_ToBeReleased_ModReqItem& select_id_E_RABs_ToBeReleased_ModReqItem() { return set<E_RABs_ToBeReleased_ModReqItem>(1); }
23133 E_RABs_ToBeReleased_ModReqItem const* get_id_E_RABs_ToBeReleased_ModReqItem() const { return get<E_RABs_ToBeReleased_ModReqItem>(1); }
23134 bool is_unknown() const { return type == 2; }
23139 case 1: var.destroy<E_RABs_ToBeReleased_ModReqItem>(); break;
23141 type = 0; ref_nested().clear();
23143 template<typename V> static inline void enumerate(V& v)
23145 v.template operator()<E_RABs_ToBeReleased_ModReqItem>(1);
23149 template<typename V> bool decode(size_t index, V& v)
23154 case 1: v(select_id_E_RABs_ToBeReleased_ModReqItem()); return true;
23155 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
23160 template<typename V> bool encode(size_t index, V& v) const
23162 if(index != type) return false;
23165 case 1: v(var.as<E_RABs_ToBeReleased_ModReqItem>()); return true;
23171 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
23172 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
23175 char dummy1[sizeof(E_RABs_ToBeReleased_ModReqItem)];
23178 asn::variant<sizeof(union_type)> var;
23182 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
23184 size_t get_index() const {return type;}
23185 bool is_unknown() const { return type == 2; }
23186 void clear() {type = 0;}
23187 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(mandatory); type=1;}
23188 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
23189 template<typename V> bool decode(V& v)
23192 if(!v(ref_nested())) return false;
23193 if(equal(mandatory)) { type = 1; return true; }
23194 else { type = 2; return true;}
23198 template<typename V> bool encode(V& v) const
23200 return v(ref_nested());
23204 template<typename V> bool decode(size_t index, V& v)
23209 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
23210 case 2: type = 2; return v(ref_nested());
23211 ref_nested().clear();
23216 template<typename V> bool encode(size_t index, V& v) const
23218 if(index != type) {return false;} return v(ref_nested());
23228 E-RABs-ToBeReleased-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqItemIEs} }
23231 struct E_RABs_ToBeReleased_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>
23233 static constexpr const char* name() {return "E_RABs_ToBeReleased_List_ModReq_elm";}
23234 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>;
23237 struct E_RABs_ToBeReleased_List_ModReq : asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>
23239 static constexpr const char* name() {return "E-RABs-ToBeReleased-List-ModReq";}
23240 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>;
23241 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
23245 E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23250 struct E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs
23252 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23254 size_t get_index() const {return type;}
23255 bool is_unknown() const { return type == 1; }
23256 void clear() {type = 0;}
23257 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23258 template<typename V> bool decode(V& v)
23261 if(!v(ref_nested())) return false;
23262 { type = 1; return true;}
23266 template<typename V> bool encode(V& v) const
23268 return v(ref_nested());
23272 template<typename V> bool decode(size_t index, V& v)
23277 case 1: type = 1; return v(ref_nested());
23278 ref_nested().clear();
23283 template<typename V> bool encode(size_t index, V& v) const
23285 if(index != type) {return false;} return v(ref_nested());
23292 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23294 size_t get_index() const {return type;}
23295 bool is_unknown() const { return type == 1; }
23296 void clear() {type = 0;}
23297 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23298 template<typename V> bool decode(V& v)
23301 if(!v(ref_nested())) return false;
23302 { type = 1; return true;}
23306 template<typename V> bool encode(V& v) const
23308 return v(ref_nested());
23312 template<typename V> bool decode(size_t index, V& v)
23317 case 1: type = 1; return v(ref_nested());
23318 ref_nested().clear();
23323 template<typename V> bool encode(size_t index, V& v) const
23325 if(index != type) {return false;} return v(ref_nested());
23332 struct Extension_t : asn::typefield<true>
23334 ~Extension_t() {clear();}
23335 size_t get_index() const {return type;}
23336 bool is_unknown() const { return type == 1; }
23339 type = 0; ref_nested().clear();
23341 template<typename V> static inline void enumerate(V& v)
23346 template<typename V> bool decode(size_t index, V& v)
23351 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23356 template<typename V> bool encode(size_t index, V& v) const
23358 if(index != type) return false;
23366 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23368 size_t get_index() const {return type;}
23369 bool is_unknown() const { return type == 1; }
23370 void clear() {type = 0;}
23371 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23372 template<typename V> bool decode(V& v)
23375 if(!v(ref_nested())) return false;
23376 { type = 1; return true;}
23380 template<typename V> bool encode(V& v) const
23382 return v(ref_nested());
23386 template<typename V> bool decode(size_t index, V& v)
23391 case 1: type = 1; return v(ref_nested());
23392 ref_nested().clear();
23397 template<typename V> bool encode(size_t index, V& v) const
23399 if(index != type) {return false;} return v(ref_nested());
23409 E-RABs-ToBeReleased-RelConfItem-SCG-Bearer ::= SEQUENCE {
23411 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
23412 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
23413 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs} } OPTIONAL,
23418 struct E_RABs_ToBeReleased_RelConfItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
23420 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-SCG-Bearer";}
23421 using parent_t = asn::sequence<4, 0, true, 3>;
23422 struct e_RAB_ID_t : E_RAB_ID
23424 static constexpr const char* name() {return "e_RAB_ID_t";}
23425 using parent_t = E_RAB_ID;
23428 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
23429 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
23430 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23432 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
23433 using parent_t = GTPtunnelEndpoint;
23434 static constexpr bool optional = true;
23437 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
23438 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
23439 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23441 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
23442 using parent_t = GTPtunnelEndpoint;
23443 static constexpr bool optional = true;
23446 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
23447 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
23448 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>
23450 static constexpr const char* name() {return "iE_Extensions_t";}
23451 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>;
23452 static constexpr bool optional = true;
23455 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23456 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23457 template<typename V> void decode(V& v)
23460 v(uL_Forwarding_GTPtunnelEndpoint);
23461 v(dL_Forwarding_GTPtunnelEndpoint);
23465 template<typename V> void encode(V& v) const
23468 v(uL_Forwarding_GTPtunnelEndpoint);
23469 v(dL_Forwarding_GTPtunnelEndpoint);
23476 uL_Forwarding_GTPtunnelEndpoint.clear();
23477 dL_Forwarding_GTPtunnelEndpoint.clear();
23478 iE_Extensions.clear();
23482 e_RAB_ID_t e_RAB_ID;
23483 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
23484 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
23485 iE_Extensions_t iE_Extensions;
23489 E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23494 struct E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs
23496 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23498 size_t get_index() const {return type;}
23499 bool is_unknown() const { return type == 1; }
23500 void clear() {type = 0;}
23501 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23502 template<typename V> bool decode(V& v)
23505 if(!v(ref_nested())) return false;
23506 { type = 1; return true;}
23510 template<typename V> bool encode(V& v) const
23512 return v(ref_nested());
23516 template<typename V> bool decode(size_t index, V& v)
23521 case 1: type = 1; return v(ref_nested());
23522 ref_nested().clear();
23527 template<typename V> bool encode(size_t index, V& v) const
23529 if(index != type) {return false;} return v(ref_nested());
23536 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23538 size_t get_index() const {return type;}
23539 bool is_unknown() const { return type == 1; }
23540 void clear() {type = 0;}
23541 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23542 template<typename V> bool decode(V& v)
23545 if(!v(ref_nested())) return false;
23546 { type = 1; return true;}
23550 template<typename V> bool encode(V& v) const
23552 return v(ref_nested());
23556 template<typename V> bool decode(size_t index, V& v)
23561 case 1: type = 1; return v(ref_nested());
23562 ref_nested().clear();
23567 template<typename V> bool encode(size_t index, V& v) const
23569 if(index != type) {return false;} return v(ref_nested());
23576 struct Extension_t : asn::typefield<true>
23578 ~Extension_t() {clear();}
23579 size_t get_index() const {return type;}
23580 bool is_unknown() const { return type == 1; }
23583 type = 0; ref_nested().clear();
23585 template<typename V> static inline void enumerate(V& v)
23590 template<typename V> bool decode(size_t index, V& v)
23595 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23600 template<typename V> bool encode(size_t index, V& v) const
23602 if(index != type) return false;
23610 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23612 size_t get_index() const {return type;}
23613 bool is_unknown() const { return type == 1; }
23614 void clear() {type = 0;}
23615 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23616 template<typename V> bool decode(V& v)
23619 if(!v(ref_nested())) return false;
23620 { type = 1; return true;}
23624 template<typename V> bool encode(V& v) const
23626 return v(ref_nested());
23630 template<typename V> bool decode(size_t index, V& v)
23635 case 1: type = 1; return v(ref_nested());
23636 ref_nested().clear();
23641 template<typename V> bool encode(size_t index, V& v) const
23643 if(index != type) {return false;} return v(ref_nested());
23653 E-RABs-ToBeReleased-RelConfItem-Split-Bearer ::= SEQUENCE {
23655 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
23656 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs} } OPTIONAL,
23661 struct E_RABs_ToBeReleased_RelConfItem_Split_Bearer : asn::sequence<3, 0, true, 2>
23663 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-Split-Bearer";}
23664 using parent_t = asn::sequence<3, 0, true, 2>;
23665 struct e_RAB_ID_t : E_RAB_ID
23667 static constexpr const char* name() {return "e_RAB_ID_t";}
23668 using parent_t = E_RAB_ID;
23671 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
23672 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
23673 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23675 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
23676 using parent_t = GTPtunnelEndpoint;
23677 static constexpr bool optional = true;
23680 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
23681 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
23682 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>
23684 static constexpr const char* name() {return "iE_Extensions_t";}
23685 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>;
23686 static constexpr bool optional = true;
23689 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23690 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23691 template<typename V> void decode(V& v)
23694 v(dL_Forwarding_GTPtunnelEndpoint);
23698 template<typename V> void encode(V& v) const
23701 v(dL_Forwarding_GTPtunnelEndpoint);
23708 dL_Forwarding_GTPtunnelEndpoint.clear();
23709 iE_Extensions.clear();
23713 e_RAB_ID_t e_RAB_ID;
23714 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
23715 iE_Extensions_t iE_Extensions;
23719 E-RABs-ToBeReleased-RelConfItem ::= CHOICE {
23720 sCG-Bearer E-RABs-ToBeReleased-RelConfItem-SCG-Bearer,
23721 split-Bearer E-RABs-ToBeReleased-RelConfItem-Split-Bearer,
23726 struct E_RABs_ToBeReleased_RelConfItem : asn::choice<2, 0, true>
23728 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem";}
23729 using parent_t = asn::choice<2, 0, true>;
23730 index_type get_index() const {return index;}
23731 bool is_unknown() const {return index == 3;}
23732 void set_unknown() { set_index(3); }
23733 ~E_RABs_ToBeReleased_RelConfItem() {clear();}
23734 struct sCG_Bearer_t : E_RABs_ToBeReleased_RelConfItem_SCG_Bearer
23736 static constexpr const char* name() {return "sCG_Bearer_t";}
23737 using parent_t = E_RABs_ToBeReleased_RelConfItem_SCG_Bearer;
23740 struct split_Bearer_t : E_RABs_ToBeReleased_RelConfItem_Split_Bearer
23742 static constexpr const char* name() {return "split_Bearer_t";}
23743 using parent_t = E_RABs_ToBeReleased_RelConfItem_Split_Bearer;
23748 switch(get_index())
23750 case 1: var.destroy<sCG_Bearer_t>(); break;
23751 case 2: var.destroy<split_Bearer_t>(); break;
23756 template<typename V> bool decode(size_t idx, V& v)
23761 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
23762 case 2: set_index(2); return v(var.build<split_Bearer_t>());
23767 template<typename V> bool encode(V& v) const
23769 switch(get_index())
23771 case 1: return v(var.as<sCG_Bearer_t>());
23772 case 2: return v(var.as<split_Bearer_t>());
23776 template<typename V> static inline void enumerate(V& v)
23778 v.template operator()<sCG_Bearer_t>(1);
23779 v.template operator()<split_Bearer_t>(2);
23782 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
23783 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
23784 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
23785 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
23787 void set_index(index_type i) {index = i; base::set();}
23790 char dummy1[sizeof(sCG_Bearer_t)];
23791 char dummy2[sizeof(split_Bearer_t)];
23794 asn::variant<sizeof(union_type)> var;
23795 index_type index {0};
23798 E-RABs-ToBeReleased-RelConfItemIEs X2AP-PROTOCOL-IES ::= {
23799 { ID id-E-RABs-ToBeReleased-RelConfItem CRITICALITY ignore TYPE E-RABs-ToBeReleased-RelConfItem PRESENCE mandatory},
23804 struct E_RABs_ToBeReleased_RelConfItemIEs
23806 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
23808 size_t get_index() const {return type;}
23809 bool is_unknown() const { return type == 2; }
23810 void clear() {type = 0;}
23811 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(id_E_RABs_ToBeReleased_RelConfItem); type=1;}
23812 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
23813 template<typename V> bool decode(V& v)
23816 if(!v(ref_nested())) return false;
23817 if(equal(id_E_RABs_ToBeReleased_RelConfItem)) { type = 1; return true; }
23818 else { type = 2; return true;}
23822 template<typename V> bool encode(V& v) const
23824 return v(ref_nested());
23828 template<typename V> bool decode(size_t index, V& v)
23833 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_RelConfItem);} return false;
23834 case 2: type = 2; return v(ref_nested());
23835 ref_nested().clear();
23840 template<typename V> bool encode(size_t index, V& v) const
23842 if(index != type) {return false;} return v(ref_nested());
23849 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
23851 size_t get_index() const {return type;}
23852 bool is_unknown() const { return type == 2; }
23853 void clear() {type = 0;}
23854 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(ignore); type=1;}
23855 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
23856 template<typename V> bool decode(V& v)
23859 if(!v(ref_nested())) return false;
23860 if(equal(ignore)) { type = 1; return true; }
23861 else { type = 2; return true;}
23865 template<typename V> bool encode(V& v) const
23867 return v(ref_nested());
23871 template<typename V> bool decode(size_t index, V& v)
23876 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
23877 case 2: type = 2; return v(ref_nested());
23878 ref_nested().clear();
23883 template<typename V> bool encode(size_t index, V& v) const
23885 if(index != type) {return false;} return v(ref_nested());
23892 struct Value_t : asn::typefield<true>
23894 ~Value_t() {clear();}
23895 size_t get_index() const {return type;}
23896 E_RABs_ToBeReleased_RelConfItem& select_id_E_RABs_ToBeReleased_RelConfItem() { return set<E_RABs_ToBeReleased_RelConfItem>(1); }
23897 E_RABs_ToBeReleased_RelConfItem const* get_id_E_RABs_ToBeReleased_RelConfItem() const { return get<E_RABs_ToBeReleased_RelConfItem>(1); }
23898 bool is_unknown() const { return type == 2; }
23903 case 1: var.destroy<E_RABs_ToBeReleased_RelConfItem>(); break;
23905 type = 0; ref_nested().clear();
23907 template<typename V> static inline void enumerate(V& v)
23909 v.template operator()<E_RABs_ToBeReleased_RelConfItem>(1);
23913 template<typename V> bool decode(size_t index, V& v)
23918 case 1: v(select_id_E_RABs_ToBeReleased_RelConfItem()); return true;
23919 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
23924 template<typename V> bool encode(size_t index, V& v) const
23926 if(index != type) return false;
23929 case 1: v(var.as<E_RABs_ToBeReleased_RelConfItem>()); return true;
23935 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
23936 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
23939 char dummy1[sizeof(E_RABs_ToBeReleased_RelConfItem)];
23942 asn::variant<sizeof(union_type)> var;
23946 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
23948 size_t get_index() const {return type;}
23949 bool is_unknown() const { return type == 2; }
23950 void clear() {type = 0;}
23951 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(mandatory); type=1;}
23952 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
23953 template<typename V> bool decode(V& v)
23956 if(!v(ref_nested())) return false;
23957 if(equal(mandatory)) { type = 1; return true; }
23958 else { type = 2; return true;}
23962 template<typename V> bool encode(V& v) const
23964 return v(ref_nested());
23968 template<typename V> bool decode(size_t index, V& v)
23973 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
23974 case 2: type = 2; return v(ref_nested());
23975 ref_nested().clear();
23980 template<typename V> bool encode(size_t index, V& v) const
23982 if(index != type) {return false;} return v(ref_nested());
23992 E-RABs-ToBeReleased-List-RelConf ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelConfItemIEs} }
23995 struct E_RABs_ToBeReleased_List_RelConf_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>
23997 static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelConf_elm";}
23998 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>;
24001 struct E_RABs_ToBeReleased_List_RelConf : asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>
24003 static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelConf";}
24004 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>;
24005 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
24009 E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24014 struct E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs
24016 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24018 size_t get_index() const {return type;}
24019 bool is_unknown() const { return type == 1; }
24020 void clear() {type = 0;}
24021 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24022 template<typename V> bool decode(V& v)
24025 if(!v(ref_nested())) return false;
24026 { type = 1; return true;}
24030 template<typename V> bool encode(V& v) const
24032 return v(ref_nested());
24036 template<typename V> bool decode(size_t index, V& v)
24041 case 1: type = 1; return v(ref_nested());
24042 ref_nested().clear();
24047 template<typename V> bool encode(size_t index, V& v) const
24049 if(index != type) {return false;} return v(ref_nested());
24056 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24058 size_t get_index() const {return type;}
24059 bool is_unknown() const { return type == 1; }
24060 void clear() {type = 0;}
24061 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24062 template<typename V> bool decode(V& v)
24065 if(!v(ref_nested())) return false;
24066 { type = 1; return true;}
24070 template<typename V> bool encode(V& v) const
24072 return v(ref_nested());
24076 template<typename V> bool decode(size_t index, V& v)
24081 case 1: type = 1; return v(ref_nested());
24082 ref_nested().clear();
24087 template<typename V> bool encode(size_t index, V& v) const
24089 if(index != type) {return false;} return v(ref_nested());
24096 struct Extension_t : asn::typefield<true>
24098 ~Extension_t() {clear();}
24099 size_t get_index() const {return type;}
24100 bool is_unknown() const { return type == 1; }
24103 type = 0; ref_nested().clear();
24105 template<typename V> static inline void enumerate(V& v)
24110 template<typename V> bool decode(size_t index, V& v)
24115 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24120 template<typename V> bool encode(size_t index, V& v) const
24122 if(index != type) return false;
24130 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24132 size_t get_index() const {return type;}
24133 bool is_unknown() const { return type == 1; }
24134 void clear() {type = 0;}
24135 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24136 template<typename V> bool decode(V& v)
24139 if(!v(ref_nested())) return false;
24140 { type = 1; return true;}
24144 template<typename V> bool encode(V& v) const
24146 return v(ref_nested());
24150 template<typename V> bool decode(size_t index, V& v)
24155 case 1: type = 1; return v(ref_nested());
24156 ref_nested().clear();
24161 template<typename V> bool encode(size_t index, V& v) const
24163 if(index != type) {return false;} return v(ref_nested());
24173 E-RABs-ToBeReleased-RelReqItem-SCG-Bearer ::= SEQUENCE {
24175 uL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
24176 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
24177 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs} } OPTIONAL,
24182 struct E_RABs_ToBeReleased_RelReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
24184 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-SCG-Bearer";}
24185 using parent_t = asn::sequence<4, 0, true, 3>;
24186 struct e_RAB_ID_t : E_RAB_ID
24188 static constexpr const char* name() {return "e_RAB_ID_t";}
24189 using parent_t = E_RAB_ID;
24192 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24193 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24194 struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24196 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
24197 using parent_t = GTPtunnelEndpoint;
24198 static constexpr bool optional = true;
24201 uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
24202 uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
24203 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24205 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
24206 using parent_t = GTPtunnelEndpoint;
24207 static constexpr bool optional = true;
24210 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
24211 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
24212 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>
24214 static constexpr const char* name() {return "iE_Extensions_t";}
24215 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>;
24216 static constexpr bool optional = true;
24219 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24220 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24221 template<typename V> void decode(V& v)
24224 v(uL_Forwarding_GTPtunnelEndpoint);
24225 v(dL_Forwarding_GTPtunnelEndpoint);
24229 template<typename V> void encode(V& v) const
24232 v(uL_Forwarding_GTPtunnelEndpoint);
24233 v(dL_Forwarding_GTPtunnelEndpoint);
24240 uL_Forwarding_GTPtunnelEndpoint.clear();
24241 dL_Forwarding_GTPtunnelEndpoint.clear();
24242 iE_Extensions.clear();
24246 e_RAB_ID_t e_RAB_ID;
24247 uL_Forwarding_GTPtunnelEndpoint_t uL_Forwarding_GTPtunnelEndpoint;
24248 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
24249 iE_Extensions_t iE_Extensions;
24253 E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24258 struct E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs
24260 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24262 size_t get_index() const {return type;}
24263 bool is_unknown() const { return type == 1; }
24264 void clear() {type = 0;}
24265 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24266 template<typename V> bool decode(V& v)
24269 if(!v(ref_nested())) return false;
24270 { type = 1; return true;}
24274 template<typename V> bool encode(V& v) const
24276 return v(ref_nested());
24280 template<typename V> bool decode(size_t index, V& v)
24285 case 1: type = 1; return v(ref_nested());
24286 ref_nested().clear();
24291 template<typename V> bool encode(size_t index, V& v) const
24293 if(index != type) {return false;} return v(ref_nested());
24300 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24302 size_t get_index() const {return type;}
24303 bool is_unknown() const { return type == 1; }
24304 void clear() {type = 0;}
24305 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24306 template<typename V> bool decode(V& v)
24309 if(!v(ref_nested())) return false;
24310 { type = 1; return true;}
24314 template<typename V> bool encode(V& v) const
24316 return v(ref_nested());
24320 template<typename V> bool decode(size_t index, V& v)
24325 case 1: type = 1; return v(ref_nested());
24326 ref_nested().clear();
24331 template<typename V> bool encode(size_t index, V& v) const
24333 if(index != type) {return false;} return v(ref_nested());
24340 struct Extension_t : asn::typefield<true>
24342 ~Extension_t() {clear();}
24343 size_t get_index() const {return type;}
24344 bool is_unknown() const { return type == 1; }
24347 type = 0; ref_nested().clear();
24349 template<typename V> static inline void enumerate(V& v)
24354 template<typename V> bool decode(size_t index, V& v)
24359 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24364 template<typename V> bool encode(size_t index, V& v) const
24366 if(index != type) return false;
24374 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24376 size_t get_index() const {return type;}
24377 bool is_unknown() const { return type == 1; }
24378 void clear() {type = 0;}
24379 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24380 template<typename V> bool decode(V& v)
24383 if(!v(ref_nested())) return false;
24384 { type = 1; return true;}
24388 template<typename V> bool encode(V& v) const
24390 return v(ref_nested());
24394 template<typename V> bool decode(size_t index, V& v)
24399 case 1: type = 1; return v(ref_nested());
24400 ref_nested().clear();
24405 template<typename V> bool encode(size_t index, V& v) const
24407 if(index != type) {return false;} return v(ref_nested());
24417 E-RABs-ToBeReleased-RelReqItem-Split-Bearer ::= SEQUENCE {
24419 dL-Forwarding-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
24420 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs} } OPTIONAL,
24425 struct E_RABs_ToBeReleased_RelReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
24427 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-Split-Bearer";}
24428 using parent_t = asn::sequence<3, 0, true, 2>;
24429 struct e_RAB_ID_t : E_RAB_ID
24431 static constexpr const char* name() {return "e_RAB_ID_t";}
24432 using parent_t = E_RAB_ID;
24435 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24436 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24437 struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24439 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
24440 using parent_t = GTPtunnelEndpoint;
24441 static constexpr bool optional = true;
24444 dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
24445 dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
24446 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>
24448 static constexpr const char* name() {return "iE_Extensions_t";}
24449 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>;
24450 static constexpr bool optional = true;
24453 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24454 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24455 template<typename V> void decode(V& v)
24458 v(dL_Forwarding_GTPtunnelEndpoint);
24462 template<typename V> void encode(V& v) const
24465 v(dL_Forwarding_GTPtunnelEndpoint);
24472 dL_Forwarding_GTPtunnelEndpoint.clear();
24473 iE_Extensions.clear();
24477 e_RAB_ID_t e_RAB_ID;
24478 dL_Forwarding_GTPtunnelEndpoint_t dL_Forwarding_GTPtunnelEndpoint;
24479 iE_Extensions_t iE_Extensions;
24483 E-RABs-ToBeReleased-RelReqItem ::= CHOICE {
24484 sCG-Bearer E-RABs-ToBeReleased-RelReqItem-SCG-Bearer,
24485 split-Bearer E-RABs-ToBeReleased-RelReqItem-Split-Bearer,
24490 struct E_RABs_ToBeReleased_RelReqItem : asn::choice<2, 0, true>
24492 static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem";}
24493 using parent_t = asn::choice<2, 0, true>;
24494 index_type get_index() const {return index;}
24495 bool is_unknown() const {return index == 3;}
24496 void set_unknown() { set_index(3); }
24497 ~E_RABs_ToBeReleased_RelReqItem() {clear();}
24498 struct sCG_Bearer_t : E_RABs_ToBeReleased_RelReqItem_SCG_Bearer
24500 static constexpr const char* name() {return "sCG_Bearer_t";}
24501 using parent_t = E_RABs_ToBeReleased_RelReqItem_SCG_Bearer;
24504 struct split_Bearer_t : E_RABs_ToBeReleased_RelReqItem_Split_Bearer
24506 static constexpr const char* name() {return "split_Bearer_t";}
24507 using parent_t = E_RABs_ToBeReleased_RelReqItem_Split_Bearer;
24512 switch(get_index())
24514 case 1: var.destroy<sCG_Bearer_t>(); break;
24515 case 2: var.destroy<split_Bearer_t>(); break;
24520 template<typename V> bool decode(size_t idx, V& v)
24525 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
24526 case 2: set_index(2); return v(var.build<split_Bearer_t>());
24531 template<typename V> bool encode(V& v) const
24533 switch(get_index())
24535 case 1: return v(var.as<sCG_Bearer_t>());
24536 case 2: return v(var.as<split_Bearer_t>());
24540 template<typename V> static inline void enumerate(V& v)
24542 v.template operator()<sCG_Bearer_t>(1);
24543 v.template operator()<split_Bearer_t>(2);
24546 sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
24547 sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
24548 split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
24549 split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
24551 void set_index(index_type i) {index = i; base::set();}
24554 char dummy1[sizeof(sCG_Bearer_t)];
24555 char dummy2[sizeof(split_Bearer_t)];
24558 asn::variant<sizeof(union_type)> var;
24559 index_type index {0};
24562 E-RABs-ToBeReleased-RelReqItemIEs X2AP-PROTOCOL-IES ::= {
24563 { ID id-E-RABs-ToBeReleased-RelReqItem CRITICALITY ignore TYPE E-RABs-ToBeReleased-RelReqItem PRESENCE mandatory},
24568 struct E_RABs_ToBeReleased_RelReqItemIEs
24570 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
24572 size_t get_index() const {return type;}
24573 bool is_unknown() const { return type == 2; }
24574 void clear() {type = 0;}
24575 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(id_E_RABs_ToBeReleased_RelReqItem); type=1;}
24576 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
24577 template<typename V> bool decode(V& v)
24580 if(!v(ref_nested())) return false;
24581 if(equal(id_E_RABs_ToBeReleased_RelReqItem)) { type = 1; return true; }
24582 else { type = 2; return true;}
24586 template<typename V> bool encode(V& v) const
24588 return v(ref_nested());
24592 template<typename V> bool decode(size_t index, V& v)
24597 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_RelReqItem);} return false;
24598 case 2: type = 2; return v(ref_nested());
24599 ref_nested().clear();
24604 template<typename V> bool encode(size_t index, V& v) const
24606 if(index != type) {return false;} return v(ref_nested());
24613 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
24615 size_t get_index() const {return type;}
24616 bool is_unknown() const { return type == 2; }
24617 void clear() {type = 0;}
24618 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(ignore); type=1;}
24619 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
24620 template<typename V> bool decode(V& v)
24623 if(!v(ref_nested())) return false;
24624 if(equal(ignore)) { type = 1; return true; }
24625 else { type = 2; return true;}
24629 template<typename V> bool encode(V& v) const
24631 return v(ref_nested());
24635 template<typename V> bool decode(size_t index, V& v)
24640 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
24641 case 2: type = 2; return v(ref_nested());
24642 ref_nested().clear();
24647 template<typename V> bool encode(size_t index, V& v) const
24649 if(index != type) {return false;} return v(ref_nested());
24656 struct Value_t : asn::typefield<true>
24658 ~Value_t() {clear();}
24659 size_t get_index() const {return type;}
24660 E_RABs_ToBeReleased_RelReqItem& select_id_E_RABs_ToBeReleased_RelReqItem() { return set<E_RABs_ToBeReleased_RelReqItem>(1); }
24661 E_RABs_ToBeReleased_RelReqItem const* get_id_E_RABs_ToBeReleased_RelReqItem() const { return get<E_RABs_ToBeReleased_RelReqItem>(1); }
24662 bool is_unknown() const { return type == 2; }
24667 case 1: var.destroy<E_RABs_ToBeReleased_RelReqItem>(); break;
24669 type = 0; ref_nested().clear();
24671 template<typename V> static inline void enumerate(V& v)
24673 v.template operator()<E_RABs_ToBeReleased_RelReqItem>(1);
24677 template<typename V> bool decode(size_t index, V& v)
24682 case 1: v(select_id_E_RABs_ToBeReleased_RelReqItem()); return true;
24683 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
24688 template<typename V> bool encode(size_t index, V& v) const
24690 if(index != type) return false;
24693 case 1: v(var.as<E_RABs_ToBeReleased_RelReqItem>()); return true;
24699 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
24700 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
24703 char dummy1[sizeof(E_RABs_ToBeReleased_RelReqItem)];
24706 asn::variant<sizeof(union_type)> var;
24710 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
24712 size_t get_index() const {return type;}
24713 bool is_unknown() const { return type == 2; }
24714 void clear() {type = 0;}
24715 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(mandatory); type=1;}
24716 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
24717 template<typename V> bool decode(V& v)
24720 if(!v(ref_nested())) return false;
24721 if(equal(mandatory)) { type = 1; return true; }
24722 else { type = 2; return true;}
24726 template<typename V> bool encode(V& v) const
24728 return v(ref_nested());
24732 template<typename V> bool decode(size_t index, V& v)
24737 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
24738 case 2: type = 2; return v(ref_nested());
24739 ref_nested().clear();
24744 template<typename V> bool encode(size_t index, V& v) const
24746 if(index != type) {return false;} return v(ref_nested());
24756 E-RABs-ToBeReleased-List-RelReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelReqItemIEs} }
24759 struct E_RABs_ToBeReleased_List_RelReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>
24761 static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelReq_elm";}
24762 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>;
24765 struct E_RABs_ToBeReleased_List_RelReq : asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>
24767 static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelReq";}
24768 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>;
24769 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
24773 E-RABs-ToBeReleased-ModReqdItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24778 struct E_RABs_ToBeReleased_ModReqdItemExtIEs
24780 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24782 size_t get_index() const {return type;}
24783 bool is_unknown() const { return type == 1; }
24784 void clear() {type = 0;}
24785 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24786 template<typename V> bool decode(V& v)
24789 if(!v(ref_nested())) return false;
24790 { type = 1; return true;}
24794 template<typename V> bool encode(V& v) const
24796 return v(ref_nested());
24800 template<typename V> bool decode(size_t index, V& v)
24805 case 1: type = 1; return v(ref_nested());
24806 ref_nested().clear();
24811 template<typename V> bool encode(size_t index, V& v) const
24813 if(index != type) {return false;} return v(ref_nested());
24820 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24822 size_t get_index() const {return type;}
24823 bool is_unknown() const { return type == 1; }
24824 void clear() {type = 0;}
24825 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24826 template<typename V> bool decode(V& v)
24829 if(!v(ref_nested())) return false;
24830 { type = 1; return true;}
24834 template<typename V> bool encode(V& v) const
24836 return v(ref_nested());
24840 template<typename V> bool decode(size_t index, V& v)
24845 case 1: type = 1; return v(ref_nested());
24846 ref_nested().clear();
24851 template<typename V> bool encode(size_t index, V& v) const
24853 if(index != type) {return false;} return v(ref_nested());
24860 struct Extension_t : asn::typefield<true>
24862 ~Extension_t() {clear();}
24863 size_t get_index() const {return type;}
24864 bool is_unknown() const { return type == 1; }
24867 type = 0; ref_nested().clear();
24869 template<typename V> static inline void enumerate(V& v)
24874 template<typename V> bool decode(size_t index, V& v)
24879 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24884 template<typename V> bool encode(size_t index, V& v) const
24886 if(index != type) return false;
24894 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24896 size_t get_index() const {return type;}
24897 bool is_unknown() const { return type == 1; }
24898 void clear() {type = 0;}
24899 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24900 template<typename V> bool decode(V& v)
24903 if(!v(ref_nested())) return false;
24904 { type = 1; return true;}
24908 template<typename V> bool encode(V& v) const
24910 return v(ref_nested());
24914 template<typename V> bool decode(size_t index, V& v)
24919 case 1: type = 1; return v(ref_nested());
24920 ref_nested().clear();
24925 template<typename V> bool encode(size_t index, V& v) const
24927 if(index != type) {return false;} return v(ref_nested());
24937 E-RABs-ToBeReleased-ModReqdItem ::= SEQUENCE {
24940 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqdItemExtIEs} } OPTIONAL,
24945 struct E_RABs_ToBeReleased_ModReqdItem : asn::sequence<3, 0, true, 1>
24947 static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqdItem";}
24948 using parent_t = asn::sequence<3, 0, true, 1>;
24949 struct e_RAB_ID_t : E_RAB_ID
24951 static constexpr const char* name() {return "e_RAB_ID_t";}
24952 using parent_t = E_RAB_ID;
24955 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24956 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24957 struct cause_t : Cause
24959 static constexpr const char* name() {return "cause_t";}
24960 using parent_t = Cause;
24963 cause_t& ref_cause() {return cause;}
24964 cause_t const& ref_cause() const {return cause;}
24965 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqdItemExtIEs>
24967 static constexpr const char* name() {return "iE_Extensions_t";}
24968 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqdItemExtIEs>;
24969 static constexpr bool optional = true;
24972 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24973 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24974 template<typename V> void decode(V& v)
24981 template<typename V> void encode(V& v) const
24992 iE_Extensions.clear();
24996 e_RAB_ID_t e_RAB_ID;
24998 iE_Extensions_t iE_Extensions;
25002 E-RABs-ToBeReleased-ModReqdItemIEs X2AP-PROTOCOL-IES ::= {
25003 { ID id-E-RABs-ToBeReleased-ModReqdItem CRITICALITY ignore TYPE E-RABs-ToBeReleased-ModReqdItem PRESENCE mandatory },
25008 struct E_RABs_ToBeReleased_ModReqdItemIEs
25010 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
25012 size_t get_index() const {return type;}
25013 bool is_unknown() const { return type == 2; }
25014 void clear() {type = 0;}
25015 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(id_E_RABs_ToBeReleased_ModReqdItem); type=1;}
25016 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
25017 template<typename V> bool decode(V& v)
25020 if(!v(ref_nested())) return false;
25021 if(equal(id_E_RABs_ToBeReleased_ModReqdItem)) { type = 1; return true; }
25022 else { type = 2; return true;}
25026 template<typename V> bool encode(V& v) const
25028 return v(ref_nested());
25032 template<typename V> bool decode(size_t index, V& v)
25037 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqdItem);} return false;
25038 case 2: type = 2; return v(ref_nested());
25039 ref_nested().clear();
25044 template<typename V> bool encode(size_t index, V& v) const
25046 if(index != type) {return false;} return v(ref_nested());
25053 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
25055 size_t get_index() const {return type;}
25056 bool is_unknown() const { return type == 2; }
25057 void clear() {type = 0;}
25058 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(ignore); type=1;}
25059 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
25060 template<typename V> bool decode(V& v)
25063 if(!v(ref_nested())) return false;
25064 if(equal(ignore)) { type = 1; return true; }
25065 else { type = 2; return true;}
25069 template<typename V> bool encode(V& v) const
25071 return v(ref_nested());
25075 template<typename V> bool decode(size_t index, V& v)
25080 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
25081 case 2: type = 2; return v(ref_nested());
25082 ref_nested().clear();
25087 template<typename V> bool encode(size_t index, V& v) const
25089 if(index != type) {return false;} return v(ref_nested());
25096 struct Value_t : asn::typefield<true>
25098 ~Value_t() {clear();}
25099 size_t get_index() const {return type;}
25100 E_RABs_ToBeReleased_ModReqdItem& select_id_E_RABs_ToBeReleased_ModReqdItem() { return set<E_RABs_ToBeReleased_ModReqdItem>(1); }
25101 E_RABs_ToBeReleased_ModReqdItem const* get_id_E_RABs_ToBeReleased_ModReqdItem() const { return get<E_RABs_ToBeReleased_ModReqdItem>(1); }
25102 bool is_unknown() const { return type == 2; }
25107 case 1: var.destroy<E_RABs_ToBeReleased_ModReqdItem>(); break;
25109 type = 0; ref_nested().clear();
25111 template<typename V> static inline void enumerate(V& v)
25113 v.template operator()<E_RABs_ToBeReleased_ModReqdItem>(1);
25117 template<typename V> bool decode(size_t index, V& v)
25122 case 1: v(select_id_E_RABs_ToBeReleased_ModReqdItem()); return true;
25123 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
25128 template<typename V> bool encode(size_t index, V& v) const
25130 if(index != type) return false;
25133 case 1: v(var.as<E_RABs_ToBeReleased_ModReqdItem>()); return true;
25139 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
25140 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
25143 char dummy1[sizeof(E_RABs_ToBeReleased_ModReqdItem)];
25146 asn::variant<sizeof(union_type)> var;
25150 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
25152 size_t get_index() const {return type;}
25153 bool is_unknown() const { return type == 2; }
25154 void clear() {type = 0;}
25155 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(mandatory); type=1;}
25156 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
25157 template<typename V> bool decode(V& v)
25160 if(!v(ref_nested())) return false;
25161 if(equal(mandatory)) { type = 1; return true; }
25162 else { type = 2; return true;}
25166 template<typename V> bool encode(V& v) const
25168 return v(ref_nested());
25172 template<typename V> bool decode(size_t index, V& v)
25177 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
25178 case 2: type = 2; return v(ref_nested());
25179 ref_nested().clear();
25184 template<typename V> bool encode(size_t index, V& v) const
25186 if(index != type) {return false;} return v(ref_nested());
25196 E-RABs-ToBeReleased-ModReqd ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqdItemIEs} }
25199 struct E_RABs_ToBeReleased_ModReqd_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>
25201 static constexpr const char* name() {return "E_RABs_ToBeReleased_ModReqd_elm";}
25202 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>;
25205 struct E_RABs_ToBeReleased_ModReqd : asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>
25207 static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqd";}
25208 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>;
25209 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
25213 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25218 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs
25220 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25222 size_t get_index() const {return type;}
25223 bool is_unknown() const { return type == 1; }
25224 void clear() {type = 0;}
25225 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25226 template<typename V> bool decode(V& v)
25229 if(!v(ref_nested())) return false;
25230 { type = 1; return true;}
25234 template<typename V> bool encode(V& v) const
25236 return v(ref_nested());
25240 template<typename V> bool decode(size_t index, V& v)
25245 case 1: type = 1; return v(ref_nested());
25246 ref_nested().clear();
25251 template<typename V> bool encode(size_t index, V& v) const
25253 if(index != type) {return false;} return v(ref_nested());
25260 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25262 size_t get_index() const {return type;}
25263 bool is_unknown() const { return type == 1; }
25264 void clear() {type = 0;}
25265 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25266 template<typename V> bool decode(V& v)
25269 if(!v(ref_nested())) return false;
25270 { type = 1; return true;}
25274 template<typename V> bool encode(V& v) const
25276 return v(ref_nested());
25280 template<typename V> bool decode(size_t index, V& v)
25285 case 1: type = 1; return v(ref_nested());
25286 ref_nested().clear();
25291 template<typename V> bool encode(size_t index, V& v) const
25293 if(index != type) {return false;} return v(ref_nested());
25300 struct Extension_t : asn::typefield<true>
25302 ~Extension_t() {clear();}
25303 size_t get_index() const {return type;}
25304 bool is_unknown() const { return type == 1; }
25307 type = 0; ref_nested().clear();
25309 template<typename V> static inline void enumerate(V& v)
25314 template<typename V> bool decode(size_t index, V& v)
25319 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25324 template<typename V> bool encode(size_t index, V& v) const
25326 if(index != type) return false;
25334 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25336 size_t get_index() const {return type;}
25337 bool is_unknown() const { return type == 1; }
25338 void clear() {type = 0;}
25339 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25340 template<typename V> bool decode(V& v)
25343 if(!v(ref_nested())) return false;
25344 { type = 1; return true;}
25348 template<typename V> bool encode(V& v) const
25350 return v(ref_nested());
25354 template<typename V> bool decode(size_t index, V& v)
25359 case 1: type = 1; return v(ref_nested());
25360 ref_nested().clear();
25365 template<typename V> bool encode(size_t index, V& v) const
25367 if(index != type) {return false;} return v(ref_nested());
25377 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent ::= SEQUENCE {
25378 uL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
25379 dL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
25380 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
25385 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
25387 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent";}
25388 using parent_t = asn::sequence<3, 0, true, 3>;
25389 struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
25391 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
25392 using parent_t = GTPtunnelEndpoint;
25393 static constexpr bool optional = true;
25396 uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
25397 uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
25398 struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
25400 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
25401 using parent_t = GTPtunnelEndpoint;
25402 static constexpr bool optional = true;
25405 dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
25406 dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
25407 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>
25409 static constexpr const char* name() {return "iE_Extensions_t";}
25410 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>;
25411 static constexpr bool optional = true;
25414 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25415 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25416 template<typename V> void decode(V& v)
25418 v(uL_GTPtunnelEndpoint);
25419 v(dL_GTPtunnelEndpoint);
25423 template<typename V> void encode(V& v) const
25425 v(uL_GTPtunnelEndpoint);
25426 v(dL_GTPtunnelEndpoint);
25432 uL_GTPtunnelEndpoint.clear();
25433 dL_GTPtunnelEndpoint.clear();
25434 iE_Extensions.clear();
25438 uL_GTPtunnelEndpoint_t uL_GTPtunnelEndpoint;
25439 dL_GTPtunnelEndpoint_t dL_GTPtunnelEndpoint;
25440 iE_Extensions_t iE_Extensions;
25444 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25449 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs
25451 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25453 size_t get_index() const {return type;}
25454 bool is_unknown() const { return type == 1; }
25455 void clear() {type = 0;}
25456 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25457 template<typename V> bool decode(V& v)
25460 if(!v(ref_nested())) return false;
25461 { type = 1; return true;}
25465 template<typename V> bool encode(V& v) const
25467 return v(ref_nested());
25471 template<typename V> bool decode(size_t index, V& v)
25476 case 1: type = 1; return v(ref_nested());
25477 ref_nested().clear();
25482 template<typename V> bool encode(size_t index, V& v) const
25484 if(index != type) {return false;} return v(ref_nested());
25491 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25493 size_t get_index() const {return type;}
25494 bool is_unknown() const { return type == 1; }
25495 void clear() {type = 0;}
25496 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25497 template<typename V> bool decode(V& v)
25500 if(!v(ref_nested())) return false;
25501 { type = 1; return true;}
25505 template<typename V> bool encode(V& v) const
25507 return v(ref_nested());
25511 template<typename V> bool decode(size_t index, V& v)
25516 case 1: type = 1; return v(ref_nested());
25517 ref_nested().clear();
25522 template<typename V> bool encode(size_t index, V& v) const
25524 if(index != type) {return false;} return v(ref_nested());
25531 struct Extension_t : asn::typefield<true>
25533 ~Extension_t() {clear();}
25534 size_t get_index() const {return type;}
25535 bool is_unknown() const { return type == 1; }
25538 type = 0; ref_nested().clear();
25540 template<typename V> static inline void enumerate(V& v)
25545 template<typename V> bool decode(size_t index, V& v)
25550 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25555 template<typename V> bool encode(size_t index, V& v) const
25557 if(index != type) return false;
25565 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25567 size_t get_index() const {return type;}
25568 bool is_unknown() const { return type == 1; }
25569 void clear() {type = 0;}
25570 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25571 template<typename V> bool decode(V& v)
25574 if(!v(ref_nested())) return false;
25575 { type = 1; return true;}
25579 template<typename V> bool encode(V& v) const
25581 return v(ref_nested());
25585 template<typename V> bool decode(size_t index, V& v)
25590 case 1: type = 1; return v(ref_nested());
25591 ref_nested().clear();
25596 template<typename V> bool encode(size_t index, V& v) const
25598 if(index != type) {return false;} return v(ref_nested());
25608 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
25609 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
25614 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
25616 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent";}
25617 using parent_t = asn::sequence<1, 0, true, 1>;
25618 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>
25620 static constexpr const char* name() {return "iE_Extensions_t";}
25621 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>;
25622 static constexpr bool optional = true;
25625 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25626 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25627 template<typename V> void decode(V& v)
25632 template<typename V> void encode(V& v) const
25639 iE_Extensions.clear();
25643 iE_Extensions_t iE_Extensions;
25647 E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25652 struct E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs
25654 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25656 size_t get_index() const {return type;}
25657 bool is_unknown() const { return type == 1; }
25658 void clear() {type = 0;}
25659 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25660 template<typename V> bool decode(V& v)
25663 if(!v(ref_nested())) return false;
25664 { type = 1; return true;}
25668 template<typename V> bool encode(V& v) const
25670 return v(ref_nested());
25674 template<typename V> bool decode(size_t index, V& v)
25679 case 1: type = 1; return v(ref_nested());
25680 ref_nested().clear();
25685 template<typename V> bool encode(size_t index, V& v) const
25687 if(index != type) {return false;} return v(ref_nested());
25694 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25696 size_t get_index() const {return type;}
25697 bool is_unknown() const { return type == 1; }
25698 void clear() {type = 0;}
25699 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25700 template<typename V> bool decode(V& v)
25703 if(!v(ref_nested())) return false;
25704 { type = 1; return true;}
25708 template<typename V> bool encode(V& v) const
25710 return v(ref_nested());
25714 template<typename V> bool decode(size_t index, V& v)
25719 case 1: type = 1; return v(ref_nested());
25720 ref_nested().clear();
25725 template<typename V> bool encode(size_t index, V& v) const
25727 if(index != type) {return false;} return v(ref_nested());
25734 struct Extension_t : asn::typefield<true>
25736 ~Extension_t() {clear();}
25737 size_t get_index() const {return type;}
25738 bool is_unknown() const { return type == 1; }
25741 type = 0; ref_nested().clear();
25743 template<typename V> static inline void enumerate(V& v)
25748 template<typename V> bool decode(size_t index, V& v)
25753 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25758 template<typename V> bool encode(size_t index, V& v) const
25760 if(index != type) return false;
25768 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25770 size_t get_index() const {return type;}
25771 bool is_unknown() const { return type == 1; }
25772 void clear() {type = 0;}
25773 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25774 template<typename V> bool decode(V& v)
25777 if(!v(ref_nested())) return false;
25778 { type = 1; return true;}
25782 template<typename V> bool encode(V& v) const
25784 return v(ref_nested());
25788 template<typename V> bool decode(size_t index, V& v)
25793 case 1: type = 1; return v(ref_nested());
25794 ref_nested().clear();
25799 template<typename V> bool encode(size_t index, V& v) const
25801 if(index != type) {return false;} return v(ref_nested());
25811 E-RABs-ToBeReleased-SgNBChaConf-Item ::= SEQUENCE {
25813 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
25814 resource-configuration CHOICE {
25815 sgNBPDCPpresent E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent,
25816 sgNBPDCPnotpresent E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent,
25819 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs} } OPTIONAL,
25824 struct E_RABs_ToBeReleased_SgNBChaConf_Item : asn::sequence<4, 0, true, 1>
25826 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item";}
25827 using parent_t = asn::sequence<4, 0, true, 1>;
25828 struct e_RAB_ID_t : E_RAB_ID
25830 static constexpr const char* name() {return "e_RAB_ID_t";}
25831 using parent_t = E_RAB_ID;
25834 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
25835 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
25836 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
25838 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
25839 using parent_t = EN_DC_ResourceConfiguration;
25842 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
25843 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
25844 struct resource_configuration_t : asn::choice<2, 0, true>
25846 static constexpr const char* name() {return "resource_configuration_t";}
25847 using parent_t = asn::choice<2, 0, true>;
25848 index_type get_index() const {return index;}
25849 bool is_unknown() const {return index == 3;}
25850 void set_unknown() { set_index(3); }
25851 ~resource_configuration_t() {clear();}
25852 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent
25854 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
25855 using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent;
25858 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent
25860 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
25861 using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent;
25866 switch(get_index())
25868 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
25869 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
25874 template<typename V> bool decode(size_t idx, V& v)
25879 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
25880 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
25885 template<typename V> bool encode(V& v) const
25887 switch(get_index())
25889 case 1: return v(var.as<sgNBPDCPpresent_t>());
25890 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
25894 template<typename V> static inline void enumerate(V& v)
25896 v.template operator()<sgNBPDCPpresent_t>(1);
25897 v.template operator()<sgNBPDCPnotpresent_t>(2);
25900 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
25901 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
25902 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
25903 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
25905 void set_index(index_type i) {index = i; base::set();}
25908 char dummy1[sizeof(sgNBPDCPpresent_t)];
25909 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
25912 asn::variant<sizeof(union_type)> var;
25913 index_type index {0};
25915 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
25916 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
25917 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>
25919 static constexpr const char* name() {return "iE_Extensions_t";}
25920 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>;
25921 static constexpr bool optional = true;
25924 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25925 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25926 template<typename V> void decode(V& v)
25929 v(en_DC_ResourceConfiguration);
25930 v(resource_configuration);
25934 template<typename V> void encode(V& v) const
25937 v(en_DC_ResourceConfiguration);
25938 v(resource_configuration);
25945 en_DC_ResourceConfiguration.clear();
25946 resource_configuration.clear();
25947 iE_Extensions.clear();
25951 e_RAB_ID_t e_RAB_ID;
25952 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
25953 resource_configuration_t resource_configuration;
25954 iE_Extensions_t iE_Extensions;
25958 E-RABs-ToBeReleased-SgNBChaConf-ItemIEs X2AP-PROTOCOL-IES ::= {
25959 { ID id-E-RABs-ToBeReleased-SgNBChaConf-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBChaConf-Item PRESENCE mandatory},
25964 struct E_RABs_ToBeReleased_SgNBChaConf_ItemIEs
25966 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
25968 size_t get_index() const {return type;}
25969 bool is_unknown() const { return type == 2; }
25970 void clear() {type = 0;}
25971 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(id_E_RABs_ToBeReleased_SgNBChaConf_Item); type=1;}
25972 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
25973 template<typename V> bool decode(V& v)
25976 if(!v(ref_nested())) return false;
25977 if(equal(id_E_RABs_ToBeReleased_SgNBChaConf_Item)) { type = 1; return true; }
25978 else { type = 2; return true;}
25982 template<typename V> bool encode(V& v) const
25984 return v(ref_nested());
25988 template<typename V> bool decode(size_t index, V& v)
25993 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBChaConf_Item);} return false;
25994 case 2: type = 2; return v(ref_nested());
25995 ref_nested().clear();
26000 template<typename V> bool encode(size_t index, V& v) const
26002 if(index != type) {return false;} return v(ref_nested());
26009 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
26011 size_t get_index() const {return type;}
26012 bool is_unknown() const { return type == 2; }
26013 void clear() {type = 0;}
26014 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(ignore); type=1;}
26015 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
26016 template<typename V> bool decode(V& v)
26019 if(!v(ref_nested())) return false;
26020 if(equal(ignore)) { type = 1; return true; }
26021 else { type = 2; return true;}
26025 template<typename V> bool encode(V& v) const
26027 return v(ref_nested());
26031 template<typename V> bool decode(size_t index, V& v)
26036 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26037 case 2: type = 2; return v(ref_nested());
26038 ref_nested().clear();
26043 template<typename V> bool encode(size_t index, V& v) const
26045 if(index != type) {return false;} return v(ref_nested());
26052 struct Value_t : asn::typefield<true>
26054 ~Value_t() {clear();}
26055 size_t get_index() const {return type;}
26056 E_RABs_ToBeReleased_SgNBChaConf_Item& select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { return set<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
26057 E_RABs_ToBeReleased_SgNBChaConf_Item const* get_id_E_RABs_ToBeReleased_SgNBChaConf_Item() const { return get<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
26058 bool is_unknown() const { return type == 2; }
26063 case 1: var.destroy<E_RABs_ToBeReleased_SgNBChaConf_Item>(); break;
26065 type = 0; ref_nested().clear();
26067 template<typename V> static inline void enumerate(V& v)
26069 v.template operator()<E_RABs_ToBeReleased_SgNBChaConf_Item>(1);
26073 template<typename V> bool decode(size_t index, V& v)
26078 case 1: v(select_id_E_RABs_ToBeReleased_SgNBChaConf_Item()); return true;
26079 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
26084 template<typename V> bool encode(size_t index, V& v) const
26086 if(index != type) return false;
26089 case 1: v(var.as<E_RABs_ToBeReleased_SgNBChaConf_Item>()); return true;
26095 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
26096 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
26099 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBChaConf_Item)];
26102 asn::variant<sizeof(union_type)> var;
26106 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
26108 size_t get_index() const {return type;}
26109 bool is_unknown() const { return type == 2; }
26110 void clear() {type = 0;}
26111 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(mandatory); type=1;}
26112 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
26113 template<typename V> bool decode(V& v)
26116 if(!v(ref_nested())) return false;
26117 if(equal(mandatory)) { type = 1; return true; }
26118 else { type = 2; return true;}
26122 template<typename V> bool encode(V& v) const
26124 return v(ref_nested());
26128 template<typename V> bool decode(size_t index, V& v)
26133 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
26134 case 2: type = 2; return v(ref_nested());
26135 ref_nested().clear();
26140 template<typename V> bool encode(size_t index, V& v) const
26142 if(index != type) {return false;} return v(ref_nested());
26152 E-RABs-ToBeReleased-SgNBChaConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBChaConf-ItemIEs} }
26155 struct E_RABs_ToBeReleased_SgNBChaConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>
26157 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBChaConfList_elm";}
26158 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>;
26161 struct E_RABs_ToBeReleased_SgNBChaConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>
26163 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConfList";}
26164 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>;
26165 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
26169 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26174 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs
26176 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26178 size_t get_index() const {return type;}
26179 bool is_unknown() const { return type == 1; }
26180 void clear() {type = 0;}
26181 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26182 template<typename V> bool decode(V& v)
26185 if(!v(ref_nested())) return false;
26186 { type = 1; return true;}
26190 template<typename V> bool encode(V& v) const
26192 return v(ref_nested());
26196 template<typename V> bool decode(size_t index, V& v)
26201 case 1: type = 1; return v(ref_nested());
26202 ref_nested().clear();
26207 template<typename V> bool encode(size_t index, V& v) const
26209 if(index != type) {return false;} return v(ref_nested());
26216 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26218 size_t get_index() const {return type;}
26219 bool is_unknown() const { return type == 1; }
26220 void clear() {type = 0;}
26221 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26222 template<typename V> bool decode(V& v)
26225 if(!v(ref_nested())) return false;
26226 { type = 1; return true;}
26230 template<typename V> bool encode(V& v) const
26232 return v(ref_nested());
26236 template<typename V> bool decode(size_t index, V& v)
26241 case 1: type = 1; return v(ref_nested());
26242 ref_nested().clear();
26247 template<typename V> bool encode(size_t index, V& v) const
26249 if(index != type) {return false;} return v(ref_nested());
26256 struct Extension_t : asn::typefield<true>
26258 ~Extension_t() {clear();}
26259 size_t get_index() const {return type;}
26260 bool is_unknown() const { return type == 1; }
26263 type = 0; ref_nested().clear();
26265 template<typename V> static inline void enumerate(V& v)
26270 template<typename V> bool decode(size_t index, V& v)
26275 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26280 template<typename V> bool encode(size_t index, V& v) const
26282 if(index != type) return false;
26290 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26292 size_t get_index() const {return type;}
26293 bool is_unknown() const { return type == 1; }
26294 void clear() {type = 0;}
26295 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26296 template<typename V> bool decode(V& v)
26299 if(!v(ref_nested())) return false;
26300 { type = 1; return true;}
26304 template<typename V> bool encode(V& v) const
26306 return v(ref_nested());
26310 template<typename V> bool decode(size_t index, V& v)
26315 case 1: type = 1; return v(ref_nested());
26316 ref_nested().clear();
26321 template<typename V> bool encode(size_t index, V& v) const
26323 if(index != type) {return false;} return v(ref_nested());
26333 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
26334 dL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
26335 uL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
26336 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
26341 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
26343 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent";}
26344 using parent_t = asn::sequence<3, 0, true, 3>;
26345 struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
26347 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
26348 using parent_t = GTPtunnelEndpoint;
26349 static constexpr bool optional = true;
26352 dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
26353 dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
26354 struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
26356 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
26357 using parent_t = GTPtunnelEndpoint;
26358 static constexpr bool optional = true;
26361 uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
26362 uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
26363 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
26365 static constexpr const char* name() {return "iE_Extensions_t";}
26366 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
26367 static constexpr bool optional = true;
26370 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26371 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26372 template<typename V> void decode(V& v)
26374 v(dL_GTPtunnelEndpoint);
26375 v(uL_GTPtunnelEndpoint);
26379 template<typename V> void encode(V& v) const
26381 v(dL_GTPtunnelEndpoint);
26382 v(uL_GTPtunnelEndpoint);
26388 dL_GTPtunnelEndpoint.clear();
26389 uL_GTPtunnelEndpoint.clear();
26390 iE_Extensions.clear();
26394 dL_GTPtunnelEndpoint_t dL_GTPtunnelEndpoint;
26395 uL_GTPtunnelEndpoint_t uL_GTPtunnelEndpoint;
26396 iE_Extensions_t iE_Extensions;
26400 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26405 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
26407 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26409 size_t get_index() const {return type;}
26410 bool is_unknown() const { return type == 1; }
26411 void clear() {type = 0;}
26412 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26413 template<typename V> bool decode(V& v)
26416 if(!v(ref_nested())) return false;
26417 { type = 1; return true;}
26421 template<typename V> bool encode(V& v) const
26423 return v(ref_nested());
26427 template<typename V> bool decode(size_t index, V& v)
26432 case 1: type = 1; return v(ref_nested());
26433 ref_nested().clear();
26438 template<typename V> bool encode(size_t index, V& v) const
26440 if(index != type) {return false;} return v(ref_nested());
26447 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26449 size_t get_index() const {return type;}
26450 bool is_unknown() const { return type == 1; }
26451 void clear() {type = 0;}
26452 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26453 template<typename V> bool decode(V& v)
26456 if(!v(ref_nested())) return false;
26457 { type = 1; return true;}
26461 template<typename V> bool encode(V& v) const
26463 return v(ref_nested());
26467 template<typename V> bool decode(size_t index, V& v)
26472 case 1: type = 1; return v(ref_nested());
26473 ref_nested().clear();
26478 template<typename V> bool encode(size_t index, V& v) const
26480 if(index != type) {return false;} return v(ref_nested());
26487 struct Extension_t : asn::typefield<true>
26489 ~Extension_t() {clear();}
26490 size_t get_index() const {return type;}
26491 bool is_unknown() const { return type == 1; }
26494 type = 0; ref_nested().clear();
26496 template<typename V> static inline void enumerate(V& v)
26501 template<typename V> bool decode(size_t index, V& v)
26506 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26511 template<typename V> bool encode(size_t index, V& v) const
26513 if(index != type) return false;
26521 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26523 size_t get_index() const {return type;}
26524 bool is_unknown() const { return type == 1; }
26525 void clear() {type = 0;}
26526 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26527 template<typename V> bool decode(V& v)
26530 if(!v(ref_nested())) return false;
26531 { type = 1; return true;}
26535 template<typename V> bool encode(V& v) const
26537 return v(ref_nested());
26541 template<typename V> bool decode(size_t index, V& v)
26546 case 1: type = 1; return v(ref_nested());
26547 ref_nested().clear();
26552 template<typename V> bool encode(size_t index, V& v) const
26554 if(index != type) {return false;} return v(ref_nested());
26564 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
26565 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
26570 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
26572 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent";}
26573 using parent_t = asn::sequence<1, 0, true, 1>;
26574 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
26576 static constexpr const char* name() {return "iE_Extensions_t";}
26577 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
26578 static constexpr bool optional = true;
26581 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26582 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26583 template<typename V> void decode(V& v)
26588 template<typename V> void encode(V& v) const
26595 iE_Extensions.clear();
26599 iE_Extensions_t iE_Extensions;
26603 E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26608 struct E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs
26610 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26612 size_t get_index() const {return type;}
26613 bool is_unknown() const { return type == 1; }
26614 void clear() {type = 0;}
26615 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26616 template<typename V> bool decode(V& v)
26619 if(!v(ref_nested())) return false;
26620 { type = 1; return true;}
26624 template<typename V> bool encode(V& v) const
26626 return v(ref_nested());
26630 template<typename V> bool decode(size_t index, V& v)
26635 case 1: type = 1; return v(ref_nested());
26636 ref_nested().clear();
26641 template<typename V> bool encode(size_t index, V& v) const
26643 if(index != type) {return false;} return v(ref_nested());
26650 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26652 size_t get_index() const {return type;}
26653 bool is_unknown() const { return type == 1; }
26654 void clear() {type = 0;}
26655 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26656 template<typename V> bool decode(V& v)
26659 if(!v(ref_nested())) return false;
26660 { type = 1; return true;}
26664 template<typename V> bool encode(V& v) const
26666 return v(ref_nested());
26670 template<typename V> bool decode(size_t index, V& v)
26675 case 1: type = 1; return v(ref_nested());
26676 ref_nested().clear();
26681 template<typename V> bool encode(size_t index, V& v) const
26683 if(index != type) {return false;} return v(ref_nested());
26690 struct Extension_t : asn::typefield<true>
26692 ~Extension_t() {clear();}
26693 size_t get_index() const {return type;}
26694 bool is_unknown() const { return type == 1; }
26697 type = 0; ref_nested().clear();
26699 template<typename V> static inline void enumerate(V& v)
26704 template<typename V> bool decode(size_t index, V& v)
26709 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26714 template<typename V> bool encode(size_t index, V& v) const
26716 if(index != type) return false;
26724 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26726 size_t get_index() const {return type;}
26727 bool is_unknown() const { return type == 1; }
26728 void clear() {type = 0;}
26729 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26730 template<typename V> bool decode(V& v)
26733 if(!v(ref_nested())) return false;
26734 { type = 1; return true;}
26738 template<typename V> bool encode(V& v) const
26740 return v(ref_nested());
26744 template<typename V> bool decode(size_t index, V& v)
26749 case 1: type = 1; return v(ref_nested());
26750 ref_nested().clear();
26755 template<typename V> bool encode(size_t index, V& v) const
26757 if(index != type) {return false;} return v(ref_nested());
26767 E-RABs-ToBeReleased-SgNBModReq-Item ::= SEQUENCE {
26769 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
26770 resource-configuration CHOICE {
26771 sgNBPDCPpresent E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent,
26772 sgNBPDCPnotpresent E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent,
26775 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs} } OPTIONAL,
26780 struct E_RABs_ToBeReleased_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
26782 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item";}
26783 using parent_t = asn::sequence<4, 0, true, 1>;
26784 struct e_RAB_ID_t : E_RAB_ID
26786 static constexpr const char* name() {return "e_RAB_ID_t";}
26787 using parent_t = E_RAB_ID;
26790 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
26791 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
26792 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
26794 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
26795 using parent_t = EN_DC_ResourceConfiguration;
26798 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
26799 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
26800 struct resource_configuration_t : asn::choice<2, 0, true>
26802 static constexpr const char* name() {return "resource_configuration_t";}
26803 using parent_t = asn::choice<2, 0, true>;
26804 index_type get_index() const {return index;}
26805 bool is_unknown() const {return index == 3;}
26806 void set_unknown() { set_index(3); }
26807 ~resource_configuration_t() {clear();}
26808 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent
26810 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
26811 using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent;
26814 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent
26816 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
26817 using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent;
26822 switch(get_index())
26824 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
26825 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
26830 template<typename V> bool decode(size_t idx, V& v)
26835 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
26836 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
26841 template<typename V> bool encode(V& v) const
26843 switch(get_index())
26845 case 1: return v(var.as<sgNBPDCPpresent_t>());
26846 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
26850 template<typename V> static inline void enumerate(V& v)
26852 v.template operator()<sgNBPDCPpresent_t>(1);
26853 v.template operator()<sgNBPDCPnotpresent_t>(2);
26856 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
26857 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
26858 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
26859 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
26861 void set_index(index_type i) {index = i; base::set();}
26864 char dummy1[sizeof(sgNBPDCPpresent_t)];
26865 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
26868 asn::variant<sizeof(union_type)> var;
26869 index_type index {0};
26871 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
26872 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
26873 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>
26875 static constexpr const char* name() {return "iE_Extensions_t";}
26876 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>;
26877 static constexpr bool optional = true;
26880 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26881 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26882 template<typename V> void decode(V& v)
26885 v(en_DC_ResourceConfiguration);
26886 v(resource_configuration);
26890 template<typename V> void encode(V& v) const
26893 v(en_DC_ResourceConfiguration);
26894 v(resource_configuration);
26901 en_DC_ResourceConfiguration.clear();
26902 resource_configuration.clear();
26903 iE_Extensions.clear();
26907 e_RAB_ID_t e_RAB_ID;
26908 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
26909 resource_configuration_t resource_configuration;
26910 iE_Extensions_t iE_Extensions;
26914 E-RABs-ToBeReleased-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
26915 { ID id-E-RABs-ToBeReleased-SgNBModReq-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBModReq-Item PRESENCE mandatory},
26920 struct E_RABs_ToBeReleased_SgNBModReq_ItemIEs
26922 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
26924 size_t get_index() const {return type;}
26925 bool is_unknown() const { return type == 2; }
26926 void clear() {type = 0;}
26927 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(id_E_RABs_ToBeReleased_SgNBModReq_Item); type=1;}
26928 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
26929 template<typename V> bool decode(V& v)
26932 if(!v(ref_nested())) return false;
26933 if(equal(id_E_RABs_ToBeReleased_SgNBModReq_Item)) { type = 1; return true; }
26934 else { type = 2; return true;}
26938 template<typename V> bool encode(V& v) const
26940 return v(ref_nested());
26944 template<typename V> bool decode(size_t index, V& v)
26949 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReq_Item);} return false;
26950 case 2: type = 2; return v(ref_nested());
26951 ref_nested().clear();
26956 template<typename V> bool encode(size_t index, V& v) const
26958 if(index != type) {return false;} return v(ref_nested());
26965 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
26967 size_t get_index() const {return type;}
26968 bool is_unknown() const { return type == 2; }
26969 void clear() {type = 0;}
26970 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(ignore); type=1;}
26971 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
26972 template<typename V> bool decode(V& v)
26975 if(!v(ref_nested())) return false;
26976 if(equal(ignore)) { type = 1; return true; }
26977 else { type = 2; return true;}
26981 template<typename V> bool encode(V& v) const
26983 return v(ref_nested());
26987 template<typename V> bool decode(size_t index, V& v)
26992 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26993 case 2: type = 2; return v(ref_nested());
26994 ref_nested().clear();
26999 template<typename V> bool encode(size_t index, V& v) const
27001 if(index != type) {return false;} return v(ref_nested());
27008 struct Value_t : asn::typefield<true>
27010 ~Value_t() {clear();}
27011 size_t get_index() const {return type;}
27012 E_RABs_ToBeReleased_SgNBModReq_Item& select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { return set<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
27013 E_RABs_ToBeReleased_SgNBModReq_Item const* get_id_E_RABs_ToBeReleased_SgNBModReq_Item() const { return get<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
27014 bool is_unknown() const { return type == 2; }
27019 case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReq_Item>(); break;
27021 type = 0; ref_nested().clear();
27023 template<typename V> static inline void enumerate(V& v)
27025 v.template operator()<E_RABs_ToBeReleased_SgNBModReq_Item>(1);
27029 template<typename V> bool decode(size_t index, V& v)
27034 case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReq_Item()); return true;
27035 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27040 template<typename V> bool encode(size_t index, V& v) const
27042 if(index != type) return false;
27045 case 1: v(var.as<E_RABs_ToBeReleased_SgNBModReq_Item>()); return true;
27051 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27052 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27055 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBModReq_Item)];
27058 asn::variant<sizeof(union_type)> var;
27062 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
27064 size_t get_index() const {return type;}
27065 bool is_unknown() const { return type == 2; }
27066 void clear() {type = 0;}
27067 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(mandatory); type=1;}
27068 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
27069 template<typename V> bool decode(V& v)
27072 if(!v(ref_nested())) return false;
27073 if(equal(mandatory)) { type = 1; return true; }
27074 else { type = 2; return true;}
27078 template<typename V> bool encode(V& v) const
27080 return v(ref_nested());
27084 template<typename V> bool decode(size_t index, V& v)
27089 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
27090 case 2: type = 2; return v(ref_nested());
27091 ref_nested().clear();
27096 template<typename V> bool encode(size_t index, V& v) const
27098 if(index != type) {return false;} return v(ref_nested());
27108 E-RABs-ToBeReleased-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReq-ItemIEs} }
27111 struct E_RABs_ToBeReleased_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>
27113 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReq_List_elm";}
27114 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>;
27117 struct E_RABs_ToBeReleased_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>
27119 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-List";}
27120 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>;
27121 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
27125 E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27126 { ID id-RLCMode-transferred CRITICALITY ignore EXTENSION RLCMode PRESENCE optional},
27131 struct E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs
27133 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27135 size_t get_index() const {return type;}
27136 bool is_unknown() const { return type == 2; }
27137 void clear() {type = 0;}
27138 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
27139 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27140 template<typename V> bool decode(V& v)
27143 if(!v(ref_nested())) return false;
27144 if(equal(id_RLCMode_transferred)) { type = 1; return true; }
27145 else { type = 2; return true;}
27149 template<typename V> bool encode(V& v) const
27151 return v(ref_nested());
27155 template<typename V> bool decode(size_t index, V& v)
27160 case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
27161 case 2: type = 2; return v(ref_nested());
27162 ref_nested().clear();
27167 template<typename V> bool encode(size_t index, V& v) const
27169 if(index != type) {return false;} return v(ref_nested());
27176 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27178 size_t get_index() const {return type;}
27179 bool is_unknown() const { return type == 2; }
27180 void clear() {type = 0;}
27181 void select_id_RLCMode_transferred() { set(ignore); type=1;}
27182 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27183 template<typename V> bool decode(V& v)
27186 if(!v(ref_nested())) return false;
27187 if(equal(ignore)) { type = 1; return true; }
27188 else { type = 2; return true;}
27192 template<typename V> bool encode(V& v) const
27194 return v(ref_nested());
27198 template<typename V> bool decode(size_t index, V& v)
27203 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27204 case 2: type = 2; return v(ref_nested());
27205 ref_nested().clear();
27210 template<typename V> bool encode(size_t index, V& v) const
27212 if(index != type) {return false;} return v(ref_nested());
27219 struct Extension_t : asn::typefield<true>
27221 ~Extension_t() {clear();}
27222 size_t get_index() const {return type;}
27223 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
27224 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
27225 bool is_unknown() const { return type == 2; }
27230 case 1: var.destroy<RLCMode>(); break;
27232 type = 0; ref_nested().clear();
27234 template<typename V> static inline void enumerate(V& v)
27236 v.template operator()<RLCMode>(1);
27240 template<typename V> bool decode(size_t index, V& v)
27245 case 1: v(select_id_RLCMode_transferred()); return true;
27246 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27251 template<typename V> bool encode(size_t index, V& v) const
27253 if(index != type) return false;
27256 case 1: v(var.as<RLCMode>()); return true;
27262 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27263 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27266 char dummy1[sizeof(RLCMode)];
27269 asn::variant<sizeof(union_type)> var;
27273 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27275 size_t get_index() const {return type;}
27276 bool is_unknown() const { return type == 2; }
27277 void clear() {type = 0;}
27278 void select_id_RLCMode_transferred() { set(optional); type=1;}
27279 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27280 template<typename V> bool decode(V& v)
27283 if(!v(ref_nested())) return false;
27284 if(equal(optional)) { type = 1; return true; }
27285 else { type = 2; return true;}
27289 template<typename V> bool encode(V& v) const
27291 return v(ref_nested());
27295 template<typename V> bool decode(size_t index, V& v)
27300 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
27301 case 2: type = 2; return v(ref_nested());
27302 ref_nested().clear();
27307 template<typename V> bool encode(size_t index, V& v) const
27309 if(index != type) {return false;} return v(ref_nested());
27319 E-RABs-ToBeReleased-SgNBModReqd-Item ::= SEQUENCE {
27322 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs} } OPTIONAL,
27327 struct E_RABs_ToBeReleased_SgNBModReqd_Item : asn::sequence<3, 0, true, 1>
27329 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqd-Item";}
27330 using parent_t = asn::sequence<3, 0, true, 1>;
27331 struct e_RAB_ID_t : E_RAB_ID
27333 static constexpr const char* name() {return "e_RAB_ID_t";}
27334 using parent_t = E_RAB_ID;
27337 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
27338 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
27339 struct cause_t : Cause
27341 static constexpr const char* name() {return "cause_t";}
27342 using parent_t = Cause;
27345 cause_t& ref_cause() {return cause;}
27346 cause_t const& ref_cause() const {return cause;}
27347 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>
27349 static constexpr const char* name() {return "iE_Extensions_t";}
27350 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>;
27351 static constexpr bool optional = true;
27354 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27355 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27356 template<typename V> void decode(V& v)
27363 template<typename V> void encode(V& v) const
27374 iE_Extensions.clear();
27378 e_RAB_ID_t e_RAB_ID;
27380 iE_Extensions_t iE_Extensions;
27384 E-RABs-ToBeReleased-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
27385 { ID id-E-RABs-ToBeReleased-SgNBModReqd-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBModReqd-Item PRESENCE mandatory },
27390 struct E_RABs_ToBeReleased_SgNBModReqd_ItemIEs
27392 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
27394 size_t get_index() const {return type;}
27395 bool is_unknown() const { return type == 2; }
27396 void clear() {type = 0;}
27397 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBModReqd_Item); type=1;}
27398 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
27399 template<typename V> bool decode(V& v)
27402 if(!v(ref_nested())) return false;
27403 if(equal(id_E_RABs_ToBeReleased_SgNBModReqd_Item)) { type = 1; return true; }
27404 else { type = 2; return true;}
27408 template<typename V> bool encode(V& v) const
27410 return v(ref_nested());
27414 template<typename V> bool decode(size_t index, V& v)
27419 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReqd_Item);} return false;
27420 case 2: type = 2; return v(ref_nested());
27421 ref_nested().clear();
27426 template<typename V> bool encode(size_t index, V& v) const
27428 if(index != type) {return false;} return v(ref_nested());
27435 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
27437 size_t get_index() const {return type;}
27438 bool is_unknown() const { return type == 2; }
27439 void clear() {type = 0;}
27440 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(ignore); type=1;}
27441 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
27442 template<typename V> bool decode(V& v)
27445 if(!v(ref_nested())) return false;
27446 if(equal(ignore)) { type = 1; return true; }
27447 else { type = 2; return true;}
27451 template<typename V> bool encode(V& v) const
27453 return v(ref_nested());
27457 template<typename V> bool decode(size_t index, V& v)
27462 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27463 case 2: type = 2; return v(ref_nested());
27464 ref_nested().clear();
27469 template<typename V> bool encode(size_t index, V& v) const
27471 if(index != type) {return false;} return v(ref_nested());
27478 struct Value_t : asn::typefield<true>
27480 ~Value_t() {clear();}
27481 size_t get_index() const {return type;}
27482 E_RABs_ToBeReleased_SgNBModReqd_Item& select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { return set<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
27483 E_RABs_ToBeReleased_SgNBModReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBModReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
27484 bool is_unknown() const { return type == 2; }
27489 case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReqd_Item>(); break;
27491 type = 0; ref_nested().clear();
27493 template<typename V> static inline void enumerate(V& v)
27495 v.template operator()<E_RABs_ToBeReleased_SgNBModReqd_Item>(1);
27499 template<typename V> bool decode(size_t index, V& v)
27504 case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReqd_Item()); return true;
27505 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27510 template<typename V> bool encode(size_t index, V& v) const
27512 if(index != type) return false;
27515 case 1: v(var.as<E_RABs_ToBeReleased_SgNBModReqd_Item>()); return true;
27521 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27522 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27525 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBModReqd_Item)];
27528 asn::variant<sizeof(union_type)> var;
27532 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
27534 size_t get_index() const {return type;}
27535 bool is_unknown() const { return type == 2; }
27536 void clear() {type = 0;}
27537 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(mandatory); type=1;}
27538 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
27539 template<typename V> bool decode(V& v)
27542 if(!v(ref_nested())) return false;
27543 if(equal(mandatory)) { type = 1; return true; }
27544 else { type = 2; return true;}
27548 template<typename V> bool encode(V& v) const
27550 return v(ref_nested());
27554 template<typename V> bool decode(size_t index, V& v)
27559 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
27560 case 2: type = 2; return v(ref_nested());
27561 ref_nested().clear();
27566 template<typename V> bool encode(size_t index, V& v) const
27568 if(index != type) {return false;} return v(ref_nested());
27578 E-RABs-ToBeReleased-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReqd-ItemIEs} }
27581 struct E_RABs_ToBeReleased_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>
27583 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReqdList_elm";}
27584 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>;
27587 struct E_RABs_ToBeReleased_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>
27589 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqdList";}
27590 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>;
27591 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
27595 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27600 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs
27602 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27604 size_t get_index() const {return type;}
27605 bool is_unknown() const { return type == 1; }
27606 void clear() {type = 0;}
27607 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27608 template<typename V> bool decode(V& v)
27611 if(!v(ref_nested())) return false;
27612 { type = 1; return true;}
27616 template<typename V> bool encode(V& v) const
27618 return v(ref_nested());
27622 template<typename V> bool decode(size_t index, V& v)
27627 case 1: type = 1; return v(ref_nested());
27628 ref_nested().clear();
27633 template<typename V> bool encode(size_t index, V& v) const
27635 if(index != type) {return false;} return v(ref_nested());
27642 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27644 size_t get_index() const {return type;}
27645 bool is_unknown() const { return type == 1; }
27646 void clear() {type = 0;}
27647 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27648 template<typename V> bool decode(V& v)
27651 if(!v(ref_nested())) return false;
27652 { type = 1; return true;}
27656 template<typename V> bool encode(V& v) const
27658 return v(ref_nested());
27662 template<typename V> bool decode(size_t index, V& v)
27667 case 1: type = 1; return v(ref_nested());
27668 ref_nested().clear();
27673 template<typename V> bool encode(size_t index, V& v) const
27675 if(index != type) {return false;} return v(ref_nested());
27682 struct Extension_t : asn::typefield<true>
27684 ~Extension_t() {clear();}
27685 size_t get_index() const {return type;}
27686 bool is_unknown() const { return type == 1; }
27689 type = 0; ref_nested().clear();
27691 template<typename V> static inline void enumerate(V& v)
27696 template<typename V> bool decode(size_t index, V& v)
27701 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27706 template<typename V> bool encode(size_t index, V& v) const
27708 if(index != type) return false;
27716 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27718 size_t get_index() const {return type;}
27719 bool is_unknown() const { return type == 1; }
27720 void clear() {type = 0;}
27721 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27722 template<typename V> bool decode(V& v)
27725 if(!v(ref_nested())) return false;
27726 { type = 1; return true;}
27730 template<typename V> bool encode(V& v) const
27732 return v(ref_nested());
27736 template<typename V> bool decode(size_t index, V& v)
27741 case 1: type = 1; return v(ref_nested());
27742 ref_nested().clear();
27747 template<typename V> bool encode(size_t index, V& v) const
27749 if(index != type) {return false;} return v(ref_nested());
27759 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent ::= SEQUENCE {
27760 uL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
27761 dL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
27762 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
27767 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
27769 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent";}
27770 using parent_t = asn::sequence<3, 0, true, 3>;
27771 struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
27773 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
27774 using parent_t = GTPtunnelEndpoint;
27775 static constexpr bool optional = true;
27778 uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
27779 uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
27780 struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
27782 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
27783 using parent_t = GTPtunnelEndpoint;
27784 static constexpr bool optional = true;
27787 dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
27788 dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
27789 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>
27791 static constexpr const char* name() {return "iE_Extensions_t";}
27792 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>;
27793 static constexpr bool optional = true;
27796 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27797 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27798 template<typename V> void decode(V& v)
27800 v(uL_GTPtunnelEndpoint);
27801 v(dL_GTPtunnelEndpoint);
27805 template<typename V> void encode(V& v) const
27807 v(uL_GTPtunnelEndpoint);
27808 v(dL_GTPtunnelEndpoint);
27814 uL_GTPtunnelEndpoint.clear();
27815 dL_GTPtunnelEndpoint.clear();
27816 iE_Extensions.clear();
27820 uL_GTPtunnelEndpoint_t uL_GTPtunnelEndpoint;
27821 dL_GTPtunnelEndpoint_t dL_GTPtunnelEndpoint;
27822 iE_Extensions_t iE_Extensions;
27826 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27831 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs
27833 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27835 size_t get_index() const {return type;}
27836 bool is_unknown() const { return type == 1; }
27837 void clear() {type = 0;}
27838 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27839 template<typename V> bool decode(V& v)
27842 if(!v(ref_nested())) return false;
27843 { type = 1; return true;}
27847 template<typename V> bool encode(V& v) const
27849 return v(ref_nested());
27853 template<typename V> bool decode(size_t index, V& v)
27858 case 1: type = 1; return v(ref_nested());
27859 ref_nested().clear();
27864 template<typename V> bool encode(size_t index, V& v) const
27866 if(index != type) {return false;} return v(ref_nested());
27873 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27875 size_t get_index() const {return type;}
27876 bool is_unknown() const { return type == 1; }
27877 void clear() {type = 0;}
27878 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27879 template<typename V> bool decode(V& v)
27882 if(!v(ref_nested())) return false;
27883 { type = 1; return true;}
27887 template<typename V> bool encode(V& v) const
27889 return v(ref_nested());
27893 template<typename V> bool decode(size_t index, V& v)
27898 case 1: type = 1; return v(ref_nested());
27899 ref_nested().clear();
27904 template<typename V> bool encode(size_t index, V& v) const
27906 if(index != type) {return false;} return v(ref_nested());
27913 struct Extension_t : asn::typefield<true>
27915 ~Extension_t() {clear();}
27916 size_t get_index() const {return type;}
27917 bool is_unknown() const { return type == 1; }
27920 type = 0; ref_nested().clear();
27922 template<typename V> static inline void enumerate(V& v)
27927 template<typename V> bool decode(size_t index, V& v)
27932 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27937 template<typename V> bool encode(size_t index, V& v) const
27939 if(index != type) return false;
27947 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27949 size_t get_index() const {return type;}
27950 bool is_unknown() const { return type == 1; }
27951 void clear() {type = 0;}
27952 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27953 template<typename V> bool decode(V& v)
27956 if(!v(ref_nested())) return false;
27957 { type = 1; return true;}
27961 template<typename V> bool encode(V& v) const
27963 return v(ref_nested());
27967 template<typename V> bool decode(size_t index, V& v)
27972 case 1: type = 1; return v(ref_nested());
27973 ref_nested().clear();
27978 template<typename V> bool encode(size_t index, V& v) const
27980 if(index != type) {return false;} return v(ref_nested());
27990 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
27991 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
27996 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
27998 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent";}
27999 using parent_t = asn::sequence<1, 0, true, 1>;
28000 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>
28002 static constexpr const char* name() {return "iE_Extensions_t";}
28003 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>;
28004 static constexpr bool optional = true;
28007 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28008 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28009 template<typename V> void decode(V& v)
28014 template<typename V> void encode(V& v) const
28021 iE_Extensions.clear();
28025 iE_Extensions_t iE_Extensions;
28029 E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28034 struct E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs
28036 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28038 size_t get_index() const {return type;}
28039 bool is_unknown() const { return type == 1; }
28040 void clear() {type = 0;}
28041 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28042 template<typename V> bool decode(V& v)
28045 if(!v(ref_nested())) return false;
28046 { type = 1; return true;}
28050 template<typename V> bool encode(V& v) const
28052 return v(ref_nested());
28056 template<typename V> bool decode(size_t index, V& v)
28061 case 1: type = 1; return v(ref_nested());
28062 ref_nested().clear();
28067 template<typename V> bool encode(size_t index, V& v) const
28069 if(index != type) {return false;} return v(ref_nested());
28076 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28078 size_t get_index() const {return type;}
28079 bool is_unknown() const { return type == 1; }
28080 void clear() {type = 0;}
28081 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28082 template<typename V> bool decode(V& v)
28085 if(!v(ref_nested())) return false;
28086 { type = 1; return true;}
28090 template<typename V> bool encode(V& v) const
28092 return v(ref_nested());
28096 template<typename V> bool decode(size_t index, V& v)
28101 case 1: type = 1; return v(ref_nested());
28102 ref_nested().clear();
28107 template<typename V> bool encode(size_t index, V& v) const
28109 if(index != type) {return false;} return v(ref_nested());
28116 struct Extension_t : asn::typefield<true>
28118 ~Extension_t() {clear();}
28119 size_t get_index() const {return type;}
28120 bool is_unknown() const { return type == 1; }
28123 type = 0; ref_nested().clear();
28125 template<typename V> static inline void enumerate(V& v)
28130 template<typename V> bool decode(size_t index, V& v)
28135 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28140 template<typename V> bool encode(size_t index, V& v) const
28142 if(index != type) return false;
28150 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28152 size_t get_index() const {return type;}
28153 bool is_unknown() const { return type == 1; }
28154 void clear() {type = 0;}
28155 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28156 template<typename V> bool decode(V& v)
28159 if(!v(ref_nested())) return false;
28160 { type = 1; return true;}
28164 template<typename V> bool encode(V& v) const
28166 return v(ref_nested());
28170 template<typename V> bool decode(size_t index, V& v)
28175 case 1: type = 1; return v(ref_nested());
28176 ref_nested().clear();
28181 template<typename V> bool encode(size_t index, V& v) const
28183 if(index != type) {return false;} return v(ref_nested());
28193 E-RABs-ToBeReleased-SgNBRelConf-Item ::= SEQUENCE {
28195 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
28196 resource-configuration CHOICE {
28197 sgNBPDCPpresent E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent,
28198 sgNBPDCPnotpresent E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent,
28201 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs} } OPTIONAL,
28206 struct E_RABs_ToBeReleased_SgNBRelConf_Item : asn::sequence<4, 0, true, 1>
28208 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item";}
28209 using parent_t = asn::sequence<4, 0, true, 1>;
28210 struct e_RAB_ID_t : E_RAB_ID
28212 static constexpr const char* name() {return "e_RAB_ID_t";}
28213 using parent_t = E_RAB_ID;
28216 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
28217 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
28218 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
28220 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
28221 using parent_t = EN_DC_ResourceConfiguration;
28224 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
28225 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
28226 struct resource_configuration_t : asn::choice<2, 0, true>
28228 static constexpr const char* name() {return "resource_configuration_t";}
28229 using parent_t = asn::choice<2, 0, true>;
28230 index_type get_index() const {return index;}
28231 bool is_unknown() const {return index == 3;}
28232 void set_unknown() { set_index(3); }
28233 ~resource_configuration_t() {clear();}
28234 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent
28236 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
28237 using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent;
28240 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent
28242 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
28243 using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent;
28248 switch(get_index())
28250 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
28251 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
28256 template<typename V> bool decode(size_t idx, V& v)
28261 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
28262 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
28267 template<typename V> bool encode(V& v) const
28269 switch(get_index())
28271 case 1: return v(var.as<sgNBPDCPpresent_t>());
28272 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
28276 template<typename V> static inline void enumerate(V& v)
28278 v.template operator()<sgNBPDCPpresent_t>(1);
28279 v.template operator()<sgNBPDCPnotpresent_t>(2);
28282 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
28283 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
28284 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
28285 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
28287 void set_index(index_type i) {index = i; base::set();}
28290 char dummy1[sizeof(sgNBPDCPpresent_t)];
28291 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
28294 asn::variant<sizeof(union_type)> var;
28295 index_type index {0};
28297 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
28298 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
28299 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>
28301 static constexpr const char* name() {return "iE_Extensions_t";}
28302 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>;
28303 static constexpr bool optional = true;
28306 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28307 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28308 template<typename V> void decode(V& v)
28311 v(en_DC_ResourceConfiguration);
28312 v(resource_configuration);
28316 template<typename V> void encode(V& v) const
28319 v(en_DC_ResourceConfiguration);
28320 v(resource_configuration);
28327 en_DC_ResourceConfiguration.clear();
28328 resource_configuration.clear();
28329 iE_Extensions.clear();
28333 e_RAB_ID_t e_RAB_ID;
28334 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
28335 resource_configuration_t resource_configuration;
28336 iE_Extensions_t iE_Extensions;
28340 E-RABs-ToBeReleased-SgNBRelConf-ItemIEs X2AP-PROTOCOL-IES ::= {
28341 { ID id-E-RABs-ToBeReleased-SgNBRelConf-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelConf-Item PRESENCE mandatory},
28346 struct E_RABs_ToBeReleased_SgNBRelConf_ItemIEs
28348 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
28350 size_t get_index() const {return type;}
28351 bool is_unknown() const { return type == 2; }
28352 void clear() {type = 0;}
28353 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(id_E_RABs_ToBeReleased_SgNBRelConf_Item); type=1;}
28354 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
28355 template<typename V> bool decode(V& v)
28358 if(!v(ref_nested())) return false;
28359 if(equal(id_E_RABs_ToBeReleased_SgNBRelConf_Item)) { type = 1; return true; }
28360 else { type = 2; return true;}
28364 template<typename V> bool encode(V& v) const
28366 return v(ref_nested());
28370 template<typename V> bool decode(size_t index, V& v)
28375 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelConf_Item);} return false;
28376 case 2: type = 2; return v(ref_nested());
28377 ref_nested().clear();
28382 template<typename V> bool encode(size_t index, V& v) const
28384 if(index != type) {return false;} return v(ref_nested());
28391 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
28393 size_t get_index() const {return type;}
28394 bool is_unknown() const { return type == 2; }
28395 void clear() {type = 0;}
28396 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(ignore); type=1;}
28397 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
28398 template<typename V> bool decode(V& v)
28401 if(!v(ref_nested())) return false;
28402 if(equal(ignore)) { type = 1; return true; }
28403 else { type = 2; return true;}
28407 template<typename V> bool encode(V& v) const
28409 return v(ref_nested());
28413 template<typename V> bool decode(size_t index, V& v)
28418 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
28419 case 2: type = 2; return v(ref_nested());
28420 ref_nested().clear();
28425 template<typename V> bool encode(size_t index, V& v) const
28427 if(index != type) {return false;} return v(ref_nested());
28434 struct Value_t : asn::typefield<true>
28436 ~Value_t() {clear();}
28437 size_t get_index() const {return type;}
28438 E_RABs_ToBeReleased_SgNBRelConf_Item& select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { return set<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
28439 E_RABs_ToBeReleased_SgNBRelConf_Item const* get_id_E_RABs_ToBeReleased_SgNBRelConf_Item() const { return get<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
28440 bool is_unknown() const { return type == 2; }
28445 case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelConf_Item>(); break;
28447 type = 0; ref_nested().clear();
28449 template<typename V> static inline void enumerate(V& v)
28451 v.template operator()<E_RABs_ToBeReleased_SgNBRelConf_Item>(1);
28455 template<typename V> bool decode(size_t index, V& v)
28460 case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelConf_Item()); return true;
28461 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
28466 template<typename V> bool encode(size_t index, V& v) const
28468 if(index != type) return false;
28471 case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelConf_Item>()); return true;
28477 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
28478 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
28481 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelConf_Item)];
28484 asn::variant<sizeof(union_type)> var;
28488 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
28490 size_t get_index() const {return type;}
28491 bool is_unknown() const { return type == 2; }
28492 void clear() {type = 0;}
28493 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(mandatory); type=1;}
28494 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
28495 template<typename V> bool decode(V& v)
28498 if(!v(ref_nested())) return false;
28499 if(equal(mandatory)) { type = 1; return true; }
28500 else { type = 2; return true;}
28504 template<typename V> bool encode(V& v) const
28506 return v(ref_nested());
28510 template<typename V> bool decode(size_t index, V& v)
28515 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
28516 case 2: type = 2; return v(ref_nested());
28517 ref_nested().clear();
28522 template<typename V> bool encode(size_t index, V& v) const
28524 if(index != type) {return false;} return v(ref_nested());
28534 E-RABs-ToBeReleased-SgNBRelConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelConf-ItemIEs} }
28537 struct E_RABs_ToBeReleased_SgNBRelConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>
28539 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelConfList_elm";}
28540 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>;
28543 struct E_RABs_ToBeReleased_SgNBRelConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>
28545 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConfList";}
28546 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>;
28547 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
28551 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28556 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs
28558 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28560 size_t get_index() const {return type;}
28561 bool is_unknown() const { return type == 1; }
28562 void clear() {type = 0;}
28563 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28564 template<typename V> bool decode(V& v)
28567 if(!v(ref_nested())) return false;
28568 { type = 1; return true;}
28572 template<typename V> bool encode(V& v) const
28574 return v(ref_nested());
28578 template<typename V> bool decode(size_t index, V& v)
28583 case 1: type = 1; return v(ref_nested());
28584 ref_nested().clear();
28589 template<typename V> bool encode(size_t index, V& v) const
28591 if(index != type) {return false;} return v(ref_nested());
28598 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28600 size_t get_index() const {return type;}
28601 bool is_unknown() const { return type == 1; }
28602 void clear() {type = 0;}
28603 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28604 template<typename V> bool decode(V& v)
28607 if(!v(ref_nested())) return false;
28608 { type = 1; return true;}
28612 template<typename V> bool encode(V& v) const
28614 return v(ref_nested());
28618 template<typename V> bool decode(size_t index, V& v)
28623 case 1: type = 1; return v(ref_nested());
28624 ref_nested().clear();
28629 template<typename V> bool encode(size_t index, V& v) const
28631 if(index != type) {return false;} return v(ref_nested());
28638 struct Extension_t : asn::typefield<true>
28640 ~Extension_t() {clear();}
28641 size_t get_index() const {return type;}
28642 bool is_unknown() const { return type == 1; }
28645 type = 0; ref_nested().clear();
28647 template<typename V> static inline void enumerate(V& v)
28652 template<typename V> bool decode(size_t index, V& v)
28657 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28662 template<typename V> bool encode(size_t index, V& v) const
28664 if(index != type) return false;
28672 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28674 size_t get_index() const {return type;}
28675 bool is_unknown() const { return type == 1; }
28676 void clear() {type = 0;}
28677 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28678 template<typename V> bool decode(V& v)
28681 if(!v(ref_nested())) return false;
28682 { type = 1; return true;}
28686 template<typename V> bool encode(V& v) const
28688 return v(ref_nested());
28692 template<typename V> bool decode(size_t index, V& v)
28697 case 1: type = 1; return v(ref_nested());
28698 ref_nested().clear();
28703 template<typename V> bool encode(size_t index, V& v) const
28705 if(index != type) {return false;} return v(ref_nested());
28715 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent ::= SEQUENCE {
28716 uL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
28717 dL-GTPtunnelEndpoint GTPtunnelEndpoint OPTIONAL,
28718 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
28723 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
28725 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent";}
28726 using parent_t = asn::sequence<3, 0, true, 3>;
28727 struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
28729 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
28730 using parent_t = GTPtunnelEndpoint;
28731 static constexpr bool optional = true;
28734 uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
28735 uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
28736 struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
28738 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
28739 using parent_t = GTPtunnelEndpoint;
28740 static constexpr bool optional = true;
28743 dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
28744 dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
28745 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>
28747 static constexpr const char* name() {return "iE_Extensions_t";}
28748 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>;
28749 static constexpr bool optional = true;
28752 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28753 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28754 template<typename V> void decode(V& v)
28756 v(uL_GTPtunnelEndpoint);
28757 v(dL_GTPtunnelEndpoint);
28761 template<typename V> void encode(V& v) const
28763 v(uL_GTPtunnelEndpoint);
28764 v(dL_GTPtunnelEndpoint);
28770 uL_GTPtunnelEndpoint.clear();
28771 dL_GTPtunnelEndpoint.clear();
28772 iE_Extensions.clear();
28776 uL_GTPtunnelEndpoint_t uL_GTPtunnelEndpoint;
28777 dL_GTPtunnelEndpoint_t dL_GTPtunnelEndpoint;
28778 iE_Extensions_t iE_Extensions;
28782 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28787 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs
28789 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28791 size_t get_index() const {return type;}
28792 bool is_unknown() const { return type == 1; }
28793 void clear() {type = 0;}
28794 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28795 template<typename V> bool decode(V& v)
28798 if(!v(ref_nested())) return false;
28799 { type = 1; return true;}
28803 template<typename V> bool encode(V& v) const
28805 return v(ref_nested());
28809 template<typename V> bool decode(size_t index, V& v)
28814 case 1: type = 1; return v(ref_nested());
28815 ref_nested().clear();
28820 template<typename V> bool encode(size_t index, V& v) const
28822 if(index != type) {return false;} return v(ref_nested());
28829 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28831 size_t get_index() const {return type;}
28832 bool is_unknown() const { return type == 1; }
28833 void clear() {type = 0;}
28834 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28835 template<typename V> bool decode(V& v)
28838 if(!v(ref_nested())) return false;
28839 { type = 1; return true;}
28843 template<typename V> bool encode(V& v) const
28845 return v(ref_nested());
28849 template<typename V> bool decode(size_t index, V& v)
28854 case 1: type = 1; return v(ref_nested());
28855 ref_nested().clear();
28860 template<typename V> bool encode(size_t index, V& v) const
28862 if(index != type) {return false;} return v(ref_nested());
28869 struct Extension_t : asn::typefield<true>
28871 ~Extension_t() {clear();}
28872 size_t get_index() const {return type;}
28873 bool is_unknown() const { return type == 1; }
28876 type = 0; ref_nested().clear();
28878 template<typename V> static inline void enumerate(V& v)
28883 template<typename V> bool decode(size_t index, V& v)
28888 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28893 template<typename V> bool encode(size_t index, V& v) const
28895 if(index != type) return false;
28903 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28905 size_t get_index() const {return type;}
28906 bool is_unknown() const { return type == 1; }
28907 void clear() {type = 0;}
28908 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28909 template<typename V> bool decode(V& v)
28912 if(!v(ref_nested())) return false;
28913 { type = 1; return true;}
28917 template<typename V> bool encode(V& v) const
28919 return v(ref_nested());
28923 template<typename V> bool decode(size_t index, V& v)
28928 case 1: type = 1; return v(ref_nested());
28929 ref_nested().clear();
28934 template<typename V> bool encode(size_t index, V& v) const
28936 if(index != type) {return false;} return v(ref_nested());
28946 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
28947 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
28952 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
28954 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent";}
28955 using parent_t = asn::sequence<1, 0, true, 1>;
28956 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>
28958 static constexpr const char* name() {return "iE_Extensions_t";}
28959 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>;
28960 static constexpr bool optional = true;
28963 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28964 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28965 template<typename V> void decode(V& v)
28970 template<typename V> void encode(V& v) const
28977 iE_Extensions.clear();
28981 iE_Extensions_t iE_Extensions;
28985 E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28990 struct E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs
28992 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28994 size_t get_index() const {return type;}
28995 bool is_unknown() const { return type == 1; }
28996 void clear() {type = 0;}
28997 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28998 template<typename V> bool decode(V& v)
29001 if(!v(ref_nested())) return false;
29002 { type = 1; return true;}
29006 template<typename V> bool encode(V& v) const
29008 return v(ref_nested());
29012 template<typename V> bool decode(size_t index, V& v)
29017 case 1: type = 1; return v(ref_nested());
29018 ref_nested().clear();
29023 template<typename V> bool encode(size_t index, V& v) const
29025 if(index != type) {return false;} return v(ref_nested());
29032 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29034 size_t get_index() const {return type;}
29035 bool is_unknown() const { return type == 1; }
29036 void clear() {type = 0;}
29037 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29038 template<typename V> bool decode(V& v)
29041 if(!v(ref_nested())) return false;
29042 { type = 1; return true;}
29046 template<typename V> bool encode(V& v) const
29048 return v(ref_nested());
29052 template<typename V> bool decode(size_t index, V& v)
29057 case 1: type = 1; return v(ref_nested());
29058 ref_nested().clear();
29063 template<typename V> bool encode(size_t index, V& v) const
29065 if(index != type) {return false;} return v(ref_nested());
29072 struct Extension_t : asn::typefield<true>
29074 ~Extension_t() {clear();}
29075 size_t get_index() const {return type;}
29076 bool is_unknown() const { return type == 1; }
29079 type = 0; ref_nested().clear();
29081 template<typename V> static inline void enumerate(V& v)
29086 template<typename V> bool decode(size_t index, V& v)
29091 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
29096 template<typename V> bool encode(size_t index, V& v) const
29098 if(index != type) return false;
29106 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29108 size_t get_index() const {return type;}
29109 bool is_unknown() const { return type == 1; }
29110 void clear() {type = 0;}
29111 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29112 template<typename V> bool decode(V& v)
29115 if(!v(ref_nested())) return false;
29116 { type = 1; return true;}
29120 template<typename V> bool encode(V& v) const
29122 return v(ref_nested());
29126 template<typename V> bool decode(size_t index, V& v)
29131 case 1: type = 1; return v(ref_nested());
29132 ref_nested().clear();
29137 template<typename V> bool encode(size_t index, V& v) const
29139 if(index != type) {return false;} return v(ref_nested());
29149 E-RABs-ToBeReleased-SgNBRelReq-Item ::= SEQUENCE {
29151 en-DC-ResourceConfiguration EN-DC-ResourceConfiguration,
29152 resource-configuration CHOICE {
29153 sgNBPDCPpresent E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent,
29154 sgNBPDCPnotpresent E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent,
29157 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs} } OPTIONAL,
29162 struct E_RABs_ToBeReleased_SgNBRelReq_Item : asn::sequence<4, 0, true, 1>
29164 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item";}
29165 using parent_t = asn::sequence<4, 0, true, 1>;
29166 struct e_RAB_ID_t : E_RAB_ID
29168 static constexpr const char* name() {return "e_RAB_ID_t";}
29169 using parent_t = E_RAB_ID;
29172 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
29173 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
29174 struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
29176 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
29177 using parent_t = EN_DC_ResourceConfiguration;
29180 en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
29181 en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
29182 struct resource_configuration_t : asn::choice<2, 0, true>
29184 static constexpr const char* name() {return "resource_configuration_t";}
29185 using parent_t = asn::choice<2, 0, true>;
29186 index_type get_index() const {return index;}
29187 bool is_unknown() const {return index == 3;}
29188 void set_unknown() { set_index(3); }
29189 ~resource_configuration_t() {clear();}
29190 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent
29192 static constexpr const char* name() {return "sgNBPDCPpresent_t";}
29193 using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent;
29196 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent
29198 static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
29199 using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent;
29204 switch(get_index())
29206 case 1: var.destroy<sgNBPDCPpresent_t>(); break;
29207 case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
29212 template<typename V> bool decode(size_t idx, V& v)
29217 case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
29218 case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
29223 template<typename V> bool encode(V& v) const
29225 switch(get_index())
29227 case 1: return v(var.as<sgNBPDCPpresent_t>());
29228 case 2: return v(var.as<sgNBPDCPnotpresent_t>());
29232 template<typename V> static inline void enumerate(V& v)
29234 v.template operator()<sgNBPDCPpresent_t>(1);
29235 v.template operator()<sgNBPDCPnotpresent_t>(2);
29238 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
29239 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
29240 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
29241 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
29243 void set_index(index_type i) {index = i; base::set();}
29246 char dummy1[sizeof(sgNBPDCPpresent_t)];
29247 char dummy2[sizeof(sgNBPDCPnotpresent_t)];
29250 asn::variant<sizeof(union_type)> var;
29251 index_type index {0};
29253 resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
29254 resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
29255 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>
29257 static constexpr const char* name() {return "iE_Extensions_t";}
29258 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>;
29259 static constexpr bool optional = true;
29262 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29263 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29264 template<typename V> void decode(V& v)
29267 v(en_DC_ResourceConfiguration);
29268 v(resource_configuration);
29272 template<typename V> void encode(V& v) const
29275 v(en_DC_ResourceConfiguration);
29276 v(resource_configuration);
29283 en_DC_ResourceConfiguration.clear();
29284 resource_configuration.clear();
29285 iE_Extensions.clear();
29289 e_RAB_ID_t e_RAB_ID;
29290 en_DC_ResourceConfiguration_t en_DC_ResourceConfiguration;
29291 resource_configuration_t resource_configuration;
29292 iE_Extensions_t iE_Extensions;
29296 E-RABs-ToBeReleased-SgNBRelReq-ItemIEs X2AP-PROTOCOL-IES ::= {
29297 { ID id-E-RABs-ToBeReleased-SgNBRelReq-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelReq-Item PRESENCE mandatory},
29302 struct E_RABs_ToBeReleased_SgNBRelReq_ItemIEs
29304 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
29306 size_t get_index() const {return type;}
29307 bool is_unknown() const { return type == 2; }
29308 void clear() {type = 0;}
29309 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReq_Item); type=1;}
29310 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
29311 template<typename V> bool decode(V& v)
29314 if(!v(ref_nested())) return false;
29315 if(equal(id_E_RABs_ToBeReleased_SgNBRelReq_Item)) { type = 1; return true; }
29316 else { type = 2; return true;}
29320 template<typename V> bool encode(V& v) const
29322 return v(ref_nested());
29326 template<typename V> bool decode(size_t index, V& v)
29331 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReq_Item);} return false;
29332 case 2: type = 2; return v(ref_nested());
29333 ref_nested().clear();
29338 template<typename V> bool encode(size_t index, V& v) const
29340 if(index != type) {return false;} return v(ref_nested());
29347 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
29349 size_t get_index() const {return type;}
29350 bool is_unknown() const { return type == 2; }
29351 void clear() {type = 0;}
29352 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(ignore); type=1;}
29353 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
29354 template<typename V> bool decode(V& v)
29357 if(!v(ref_nested())) return false;
29358 if(equal(ignore)) { type = 1; return true; }
29359 else { type = 2; return true;}
29363 template<typename V> bool encode(V& v) const
29365 return v(ref_nested());
29369 template<typename V> bool decode(size_t index, V& v)
29374 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29375 case 2: type = 2; return v(ref_nested());
29376 ref_nested().clear();
29381 template<typename V> bool encode(size_t index, V& v) const
29383 if(index != type) {return false;} return v(ref_nested());
29390 struct Value_t : asn::typefield<true>
29392 ~Value_t() {clear();}
29393 size_t get_index() const {return type;}
29394 E_RABs_ToBeReleased_SgNBRelReq_Item& select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { return set<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
29395 E_RABs_ToBeReleased_SgNBRelReq_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReq_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
29396 bool is_unknown() const { return type == 2; }
29401 case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReq_Item>(); break;
29403 type = 0; ref_nested().clear();
29405 template<typename V> static inline void enumerate(V& v)
29407 v.template operator()<E_RABs_ToBeReleased_SgNBRelReq_Item>(1);
29411 template<typename V> bool decode(size_t index, V& v)
29416 case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReq_Item()); return true;
29417 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29422 template<typename V> bool encode(size_t index, V& v) const
29424 if(index != type) return false;
29427 case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelReq_Item>()); return true;
29433 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29434 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29437 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelReq_Item)];
29440 asn::variant<sizeof(union_type)> var;
29444 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
29446 size_t get_index() const {return type;}
29447 bool is_unknown() const { return type == 2; }
29448 void clear() {type = 0;}
29449 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(mandatory); type=1;}
29450 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
29451 template<typename V> bool decode(V& v)
29454 if(!v(ref_nested())) return false;
29455 if(equal(mandatory)) { type = 1; return true; }
29456 else { type = 2; return true;}
29460 template<typename V> bool encode(V& v) const
29462 return v(ref_nested());
29466 template<typename V> bool decode(size_t index, V& v)
29471 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
29472 case 2: type = 2; return v(ref_nested());
29473 ref_nested().clear();
29478 template<typename V> bool encode(size_t index, V& v) const
29480 if(index != type) {return false;} return v(ref_nested());
29490 E-RABs-ToBeReleased-SgNBRelReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReq-ItemIEs} }
29493 struct E_RABs_ToBeReleased_SgNBRelReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>
29495 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqList_elm";}
29496 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>;
29499 struct E_RABs_ToBeReleased_SgNBRelReqList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>
29501 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqList";}
29502 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>;
29503 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
29507 E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29512 struct E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs
29514 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29516 size_t get_index() const {return type;}
29517 bool is_unknown() const { return type == 1; }
29518 void clear() {type = 0;}
29519 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29520 template<typename V> bool decode(V& v)
29523 if(!v(ref_nested())) return false;
29524 { type = 1; return true;}
29528 template<typename V> bool encode(V& v) const
29530 return v(ref_nested());
29534 template<typename V> bool decode(size_t index, V& v)
29539 case 1: type = 1; return v(ref_nested());
29540 ref_nested().clear();
29545 template<typename V> bool encode(size_t index, V& v) const
29547 if(index != type) {return false;} return v(ref_nested());
29554 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29556 size_t get_index() const {return type;}
29557 bool is_unknown() const { return type == 1; }
29558 void clear() {type = 0;}
29559 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29560 template<typename V> bool decode(V& v)
29563 if(!v(ref_nested())) return false;
29564 { type = 1; return true;}
29568 template<typename V> bool encode(V& v) const
29570 return v(ref_nested());
29574 template<typename V> bool decode(size_t index, V& v)
29579 case 1: type = 1; return v(ref_nested());
29580 ref_nested().clear();
29585 template<typename V> bool encode(size_t index, V& v) const
29587 if(index != type) {return false;} return v(ref_nested());
29594 struct Extension_t : asn::typefield<true>
29596 ~Extension_t() {clear();}
29597 size_t get_index() const {return type;}
29598 bool is_unknown() const { return type == 1; }
29601 type = 0; ref_nested().clear();
29603 template<typename V> static inline void enumerate(V& v)
29608 template<typename V> bool decode(size_t index, V& v)
29613 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
29618 template<typename V> bool encode(size_t index, V& v) const
29620 if(index != type) return false;
29628 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29630 size_t get_index() const {return type;}
29631 bool is_unknown() const { return type == 1; }
29632 void clear() {type = 0;}
29633 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29634 template<typename V> bool decode(V& v)
29637 if(!v(ref_nested())) return false;
29638 { type = 1; return true;}
29642 template<typename V> bool encode(V& v) const
29644 return v(ref_nested());
29648 template<typename V> bool decode(size_t index, V& v)
29653 case 1: type = 1; return v(ref_nested());
29654 ref_nested().clear();
29659 template<typename V> bool encode(size_t index, V& v) const
29661 if(index != type) {return false;} return v(ref_nested());
29671 E-RABs-ToBeReleased-SgNBRelReqd-Item ::= SEQUENCE {
29673 rlc-Mode-transferred RLCMode,
29674 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs} } OPTIONAL,
29679 struct E_RABs_ToBeReleased_SgNBRelReqd_Item : asn::sequence<3, 0, true, 1>
29681 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqd-Item";}
29682 using parent_t = asn::sequence<3, 0, true, 1>;
29683 struct e_RAB_ID_t : E_RAB_ID
29685 static constexpr const char* name() {return "e_RAB_ID_t";}
29686 using parent_t = E_RAB_ID;
29689 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
29690 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
29691 struct rlc_Mode_transferred_t : RLCMode
29693 static constexpr const char* name() {return "rlc_Mode_transferred_t";}
29694 using parent_t = RLCMode;
29697 rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
29698 rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
29699 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>
29701 static constexpr const char* name() {return "iE_Extensions_t";}
29702 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>;
29703 static constexpr bool optional = true;
29706 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29707 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29708 template<typename V> void decode(V& v)
29711 v(rlc_Mode_transferred);
29715 template<typename V> void encode(V& v) const
29718 v(rlc_Mode_transferred);
29725 rlc_Mode_transferred.clear();
29726 iE_Extensions.clear();
29730 e_RAB_ID_t e_RAB_ID;
29731 rlc_Mode_transferred_t rlc_Mode_transferred;
29732 iE_Extensions_t iE_Extensions;
29736 E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
29737 { ID id-E-RABs-ToBeReleased-SgNBRelReqd-Item CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelReqd-Item PRESENCE mandatory},
29742 struct E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs
29744 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
29746 size_t get_index() const {return type;}
29747 bool is_unknown() const { return type == 2; }
29748 void clear() {type = 0;}
29749 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReqd_Item); type=1;}
29750 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
29751 template<typename V> bool decode(V& v)
29754 if(!v(ref_nested())) return false;
29755 if(equal(id_E_RABs_ToBeReleased_SgNBRelReqd_Item)) { type = 1; return true; }
29756 else { type = 2; return true;}
29760 template<typename V> bool encode(V& v) const
29762 return v(ref_nested());
29766 template<typename V> bool decode(size_t index, V& v)
29771 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqd_Item);} return false;
29772 case 2: type = 2; return v(ref_nested());
29773 ref_nested().clear();
29778 template<typename V> bool encode(size_t index, V& v) const
29780 if(index != type) {return false;} return v(ref_nested());
29787 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
29789 size_t get_index() const {return type;}
29790 bool is_unknown() const { return type == 2; }
29791 void clear() {type = 0;}
29792 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(ignore); type=1;}
29793 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
29794 template<typename V> bool decode(V& v)
29797 if(!v(ref_nested())) return false;
29798 if(equal(ignore)) { type = 1; return true; }
29799 else { type = 2; return true;}
29803 template<typename V> bool encode(V& v) const
29805 return v(ref_nested());
29809 template<typename V> bool decode(size_t index, V& v)
29814 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29815 case 2: type = 2; return v(ref_nested());
29816 ref_nested().clear();
29821 template<typename V> bool encode(size_t index, V& v) const
29823 if(index != type) {return false;} return v(ref_nested());
29830 struct Value_t : asn::typefield<true>
29832 ~Value_t() {clear();}
29833 size_t get_index() const {return type;}
29834 E_RABs_ToBeReleased_SgNBRelReqd_Item& select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { return set<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
29835 E_RABs_ToBeReleased_SgNBRelReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
29836 bool is_unknown() const { return type == 2; }
29841 case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReqd_Item>(); break;
29843 type = 0; ref_nested().clear();
29845 template<typename V> static inline void enumerate(V& v)
29847 v.template operator()<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1);
29851 template<typename V> bool decode(size_t index, V& v)
29856 case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item()); return true;
29857 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29862 template<typename V> bool encode(size_t index, V& v) const
29864 if(index != type) return false;
29867 case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelReqd_Item>()); return true;
29873 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29874 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29877 char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelReqd_Item)];
29880 asn::variant<sizeof(union_type)> var;
29884 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
29886 size_t get_index() const {return type;}
29887 bool is_unknown() const { return type == 2; }
29888 void clear() {type = 0;}
29889 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(mandatory); type=1;}
29890 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
29891 template<typename V> bool decode(V& v)
29894 if(!v(ref_nested())) return false;
29895 if(equal(mandatory)) { type = 1; return true; }
29896 else { type = 2; return true;}
29900 template<typename V> bool encode(V& v) const
29902 return v(ref_nested());
29906 template<typename V> bool decode(size_t index, V& v)
29911 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
29912 case 2: type = 2; return v(ref_nested());
29913 ref_nested().clear();
29918 template<typename V> bool encode(size_t index, V& v) const
29920 if(index != type) {return false;} return v(ref_nested());
29930 E-RABs-ToBeReleased-SgNBRelReqdList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs} }
29933 struct E_RABs_ToBeReleased_SgNBRelReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>
29935 static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqdList_elm";}
29936 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>;
29939 struct E_RABs_ToBeReleased_SgNBRelReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>
29941 static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqdList";}
29942 using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>;
29943 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
29947 E-RABs-ToBeSetup-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29948 { ID id-BearerType CRITICALITY reject EXTENSION BearerType PRESENCE optional},
29953 struct E_RABs_ToBeSetup_ItemExtIEs
29955 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29957 size_t get_index() const {return type;}
29958 bool is_unknown() const { return type == 2; }
29959 void clear() {type = 0;}
29960 void select_id_BearerType() { set(id_BearerType); type=1;}
29961 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29962 template<typename V> bool decode(V& v)
29965 if(!v(ref_nested())) return false;
29966 if(equal(id_BearerType)) { type = 1; return true; }
29967 else { type = 2; return true;}
29971 template<typename V> bool encode(V& v) const
29973 return v(ref_nested());
29977 template<typename V> bool decode(size_t index, V& v)
29982 case 1: type = 1; if(v(ref_nested())) { return equal(id_BearerType);} return false;
29983 case 2: type = 2; return v(ref_nested());
29984 ref_nested().clear();
29989 template<typename V> bool encode(size_t index, V& v) const
29991 if(index != type) {return false;} return v(ref_nested());
29998 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30000 size_t get_index() const {return type;}
30001 bool is_unknown() const { return type == 2; }
30002 void clear() {type = 0;}
30003 void select_id_BearerType() { set(reject); type=1;}
30004 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30005 template<typename V> bool decode(V& v)
30008 if(!v(ref_nested())) return false;
30009 if(equal(reject)) { type = 1; return true; }
30010 else { type = 2; return true;}
30014 template<typename V> bool encode(V& v) const
30016 return v(ref_nested());
30020 template<typename V> bool decode(size_t index, V& v)
30025 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
30026 case 2: type = 2; return v(ref_nested());
30027 ref_nested().clear();
30032 template<typename V> bool encode(size_t index, V& v) const
30034 if(index != type) {return false;} return v(ref_nested());
30041 struct Extension_t : asn::typefield<true>
30043 ~Extension_t() {clear();}
30044 size_t get_index() const {return type;}
30045 BearerType& select_id_BearerType() { return set<BearerType>(1); }
30046 BearerType const* get_id_BearerType() const { return get<BearerType>(1); }
30047 bool is_unknown() const { return type == 2; }
30052 case 1: var.destroy<BearerType>(); break;
30054 type = 0; ref_nested().clear();
30056 template<typename V> static inline void enumerate(V& v)
30058 v.template operator()<BearerType>(1);
30062 template<typename V> bool decode(size_t index, V& v)
30067 case 1: v(select_id_BearerType()); return true;
30068 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30073 template<typename V> bool encode(size_t index, V& v) const
30075 if(index != type) return false;
30078 case 1: v(var.as<BearerType>()); return true;
30084 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30085 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30088 char dummy1[sizeof(BearerType)];
30091 asn::variant<sizeof(union_type)> var;
30095 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30097 size_t get_index() const {return type;}
30098 bool is_unknown() const { return type == 2; }
30099 void clear() {type = 0;}
30100 void select_id_BearerType() { set(optional); type=1;}
30101 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30102 template<typename V> bool decode(V& v)
30105 if(!v(ref_nested())) return false;
30106 if(equal(optional)) { type = 1; return true; }
30107 else { type = 2; return true;}
30111 template<typename V> bool encode(V& v) const
30113 return v(ref_nested());
30117 template<typename V> bool decode(size_t index, V& v)
30122 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
30123 case 2: type = 2; return v(ref_nested());
30124 ref_nested().clear();
30129 template<typename V> bool encode(size_t index, V& v) const
30131 if(index != type) {return false;} return v(ref_nested());
30141 E-RABs-ToBeSetup-Item ::= SEQUENCE {
30143 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
30144 dL-Forwarding DL-Forwarding OPTIONAL,
30145 uL-GTPtunnelEndpoint GTPtunnelEndpoint,
30146 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeSetup-ItemExtIEs} } OPTIONAL,
30151 struct E_RABs_ToBeSetup_Item : asn::sequence<5, 0, true, 2>
30153 static constexpr const char* name() {return "E-RABs-ToBeSetup-Item";}
30154 using parent_t = asn::sequence<5, 0, true, 2>;
30155 struct e_RAB_ID_t : E_RAB_ID
30157 static constexpr const char* name() {return "e_RAB_ID_t";}
30158 using parent_t = E_RAB_ID;
30161 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30162 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30163 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
30165 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
30166 using parent_t = E_RAB_Level_QoS_Parameters;
30169 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
30170 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
30171 struct dL_Forwarding_t : DL_Forwarding
30173 static constexpr const char* name() {return "dL_Forwarding_t";}
30174 using parent_t = DL_Forwarding;
30175 static constexpr bool optional = true;
30178 dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
30179 dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
30180 struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
30182 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
30183 using parent_t = GTPtunnelEndpoint;
30186 uL_GTPtunnelEndpoint_t& ref_uL_GTPtunnelEndpoint() {return uL_GTPtunnelEndpoint;}
30187 uL_GTPtunnelEndpoint_t const& ref_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint;}
30188 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>
30190 static constexpr const char* name() {return "iE_Extensions_t";}
30191 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>;
30192 static constexpr bool optional = true;
30195 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30196 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30197 template<typename V> void decode(V& v)
30200 v(e_RAB_Level_QoS_Parameters);
30202 v(uL_GTPtunnelEndpoint);
30206 template<typename V> void encode(V& v) const
30209 v(e_RAB_Level_QoS_Parameters);
30211 v(uL_GTPtunnelEndpoint);
30218 e_RAB_Level_QoS_Parameters.clear();
30219 dL_Forwarding.clear();
30220 uL_GTPtunnelEndpoint.clear();
30221 iE_Extensions.clear();
30225 e_RAB_ID_t e_RAB_ID;
30226 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
30227 dL_Forwarding_t dL_Forwarding;
30228 uL_GTPtunnelEndpoint_t uL_GTPtunnelEndpoint;
30229 iE_Extensions_t iE_Extensions;
30233 E-RABs-ToBeSetup-ItemIEs X2AP-PROTOCOL-IES ::= {
30234 { ID id-E-RABs-ToBeSetup-Item CRITICALITY ignore TYPE E-RABs-ToBeSetup-Item PRESENCE mandatory },
30239 struct E_RABs_ToBeSetup_ItemIEs
30241 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30243 size_t get_index() const {return type;}
30244 bool is_unknown() const { return type == 2; }
30245 void clear() {type = 0;}
30246 void select_id_E_RABs_ToBeSetup_Item() { set(id_E_RABs_ToBeSetup_Item); type=1;}
30247 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30248 template<typename V> bool decode(V& v)
30251 if(!v(ref_nested())) return false;
30252 if(equal(id_E_RABs_ToBeSetup_Item)) { type = 1; return true; }
30253 else { type = 2; return true;}
30257 template<typename V> bool encode(V& v) const
30259 return v(ref_nested());
30263 template<typename V> bool decode(size_t index, V& v)
30268 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeSetup_Item);} return false;
30269 case 2: type = 2; return v(ref_nested());
30270 ref_nested().clear();
30275 template<typename V> bool encode(size_t index, V& v) const
30277 if(index != type) {return false;} return v(ref_nested());
30284 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30286 size_t get_index() const {return type;}
30287 bool is_unknown() const { return type == 2; }
30288 void clear() {type = 0;}
30289 void select_id_E_RABs_ToBeSetup_Item() { set(ignore); type=1;}
30290 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30291 template<typename V> bool decode(V& v)
30294 if(!v(ref_nested())) return false;
30295 if(equal(ignore)) { type = 1; return true; }
30296 else { type = 2; return true;}
30300 template<typename V> bool encode(V& v) const
30302 return v(ref_nested());
30306 template<typename V> bool decode(size_t index, V& v)
30311 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
30312 case 2: type = 2; return v(ref_nested());
30313 ref_nested().clear();
30318 template<typename V> bool encode(size_t index, V& v) const
30320 if(index != type) {return false;} return v(ref_nested());
30327 struct Value_t : asn::typefield<true>
30329 ~Value_t() {clear();}
30330 size_t get_index() const {return type;}
30331 E_RABs_ToBeSetup_Item& select_id_E_RABs_ToBeSetup_Item() { return set<E_RABs_ToBeSetup_Item>(1); }
30332 E_RABs_ToBeSetup_Item const* get_id_E_RABs_ToBeSetup_Item() const { return get<E_RABs_ToBeSetup_Item>(1); }
30333 bool is_unknown() const { return type == 2; }
30338 case 1: var.destroy<E_RABs_ToBeSetup_Item>(); break;
30340 type = 0; ref_nested().clear();
30342 template<typename V> static inline void enumerate(V& v)
30344 v.template operator()<E_RABs_ToBeSetup_Item>(1);
30348 template<typename V> bool decode(size_t index, V& v)
30353 case 1: v(select_id_E_RABs_ToBeSetup_Item()); return true;
30354 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30359 template<typename V> bool encode(size_t index, V& v) const
30361 if(index != type) return false;
30364 case 1: v(var.as<E_RABs_ToBeSetup_Item>()); return true;
30370 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30371 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30374 char dummy1[sizeof(E_RABs_ToBeSetup_Item)];
30377 asn::variant<sizeof(union_type)> var;
30381 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
30383 size_t get_index() const {return type;}
30384 bool is_unknown() const { return type == 2; }
30385 void clear() {type = 0;}
30386 void select_id_E_RABs_ToBeSetup_Item() { set(mandatory); type=1;}
30387 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
30388 template<typename V> bool decode(V& v)
30391 if(!v(ref_nested())) return false;
30392 if(equal(mandatory)) { type = 1; return true; }
30393 else { type = 2; return true;}
30397 template<typename V> bool encode(V& v) const
30399 return v(ref_nested());
30403 template<typename V> bool decode(size_t index, V& v)
30408 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30409 case 2: type = 2; return v(ref_nested());
30410 ref_nested().clear();
30415 template<typename V> bool encode(size_t index, V& v) const
30417 if(index != type) {return false;} return v(ref_nested());
30427 E-RABs-ToBeSetup-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetup-ItemIEs} }
30430 struct E_RABs_ToBeSetup_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>
30432 static constexpr const char* name() {return "E_RABs_ToBeSetup_List_elm";}
30433 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>;
30436 struct E_RABs_ToBeSetup_List : asn::sequenceof<E_RABs_ToBeSetup_List_elm>
30438 static constexpr const char* name() {return "E-RABs-ToBeSetup-List";}
30439 using parent_t = asn::sequenceof<E_RABs_ToBeSetup_List_elm>;
30440 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
30444 E-RABs-ToBeSetupRetrieve-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30445 { ID id-uL-GTPtunnelEndpoint CRITICALITY reject EXTENSION GTPtunnelEndpoint PRESENCE mandatory}|
30446 { ID id-dL-Forwarding CRITICALITY ignore EXTENSION DL-Forwarding PRESENCE optional },
30451 struct E_RABs_ToBeSetupRetrieve_ItemExtIEs
30453 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30455 size_t get_index() const {return type;}
30456 bool is_unknown() const { return type == 3; }
30457 void clear() {type = 0;}
30458 void select_id_uL_GTPtunnelEndpoint() { set(id_uL_GTPtunnelEndpoint); type=1;}
30459 void select_id_dL_Forwarding() { set(id_dL_Forwarding); type=2;}
30460 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30461 template<typename V> bool decode(V& v)
30464 if(!v(ref_nested())) return false;
30465 if(equal(id_uL_GTPtunnelEndpoint)) { type = 1; return true; }
30466 else if(equal(id_dL_Forwarding)) { type = 2; return true; }
30467 else { type = 3; return true;}
30471 template<typename V> bool encode(V& v) const
30473 return v(ref_nested());
30477 template<typename V> bool decode(size_t index, V& v)
30482 case 1: type = 1; if(v(ref_nested())) { return equal(id_uL_GTPtunnelEndpoint);} return false;
30483 case 2: type = 2; if(v(ref_nested())) { return equal(id_dL_Forwarding);} return false;
30484 case 3: type = 3; return v(ref_nested());
30485 ref_nested().clear();
30490 template<typename V> bool encode(size_t index, V& v) const
30492 if(index != type) {return false;} return v(ref_nested());
30499 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30501 size_t get_index() const {return type;}
30502 bool is_unknown() const { return type == 3; }
30503 void clear() {type = 0;}
30504 void select_id_uL_GTPtunnelEndpoint() { set(reject); type=1;}
30505 void select_id_dL_Forwarding() { set(ignore); type=2;}
30506 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30507 template<typename V> bool decode(V& v)
30510 if(!v(ref_nested())) return false;
30511 if(equal(reject)) { type = 1; return true; }
30512 else if(equal(ignore)) { type = 2; return true; }
30513 else { type = 3; return true;}
30517 template<typename V> bool encode(V& v) const
30519 return v(ref_nested());
30523 template<typename V> bool decode(size_t index, V& v)
30528 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
30529 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
30530 case 3: type = 3; return v(ref_nested());
30531 ref_nested().clear();
30536 template<typename V> bool encode(size_t index, V& v) const
30538 if(index != type) {return false;} return v(ref_nested());
30545 struct Extension_t : asn::typefield<true>
30547 ~Extension_t() {clear();}
30548 size_t get_index() const {return type;}
30549 GTPtunnelEndpoint& select_id_uL_GTPtunnelEndpoint() { return set<GTPtunnelEndpoint>(1); }
30550 GTPtunnelEndpoint const* get_id_uL_GTPtunnelEndpoint() const { return get<GTPtunnelEndpoint>(1); }
30551 DL_Forwarding& select_id_dL_Forwarding() { return set<DL_Forwarding>(2); }
30552 DL_Forwarding const* get_id_dL_Forwarding() const { return get<DL_Forwarding>(2); }
30553 bool is_unknown() const { return type == 3; }
30558 case 1: var.destroy<GTPtunnelEndpoint>(); break;
30559 case 2: var.destroy<DL_Forwarding>(); break;
30561 type = 0; ref_nested().clear();
30563 template<typename V> static inline void enumerate(V& v)
30565 v.template operator()<GTPtunnelEndpoint>(1);
30566 v.template operator()<DL_Forwarding>(2);
30570 template<typename V> bool decode(size_t index, V& v)
30575 case 1: v(select_id_uL_GTPtunnelEndpoint()); return true;
30576 case 2: v(select_id_dL_Forwarding()); return true;
30577 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
30582 template<typename V> bool encode(size_t index, V& v) const
30584 if(index != type) return false;
30587 case 1: v(var.as<GTPtunnelEndpoint>()); return true;
30588 case 2: v(var.as<DL_Forwarding>()); return true;
30594 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30595 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30598 char dummy1[sizeof(DL_Forwarding)];
30599 char dummy2[sizeof(GTPtunnelEndpoint)];
30602 asn::variant<sizeof(union_type)> var;
30606 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30608 size_t get_index() const {return type;}
30609 bool is_unknown() const { return type == 3; }
30610 void clear() {type = 0;}
30611 void select_id_uL_GTPtunnelEndpoint() { set(mandatory); type=1;}
30612 void select_id_dL_Forwarding() { set(optional); type=2;}
30613 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30614 template<typename V> bool decode(V& v)
30617 if(!v(ref_nested())) return false;
30618 if(equal(mandatory)) { type = 1; return true; }
30619 else if(equal(optional)) { type = 2; return true; }
30620 else { type = 3; return true;}
30624 template<typename V> bool encode(V& v) const
30626 return v(ref_nested());
30630 template<typename V> bool decode(size_t index, V& v)
30635 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30636 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
30637 case 3: type = 3; return v(ref_nested());
30638 ref_nested().clear();
30643 template<typename V> bool encode(size_t index, V& v) const
30645 if(index != type) {return false;} return v(ref_nested());
30655 E-RABs-ToBeSetupRetrieve-Item ::= SEQUENCE {
30657 e-RAB-Level-QoS-Parameters E-RAB-Level-QoS-Parameters,
30658 bearerType BearerType OPTIONAL,
30659 iE-Extensions ProtocolExtensionContainer { {E-RABs-ToBeSetupRetrieve-ItemExtIEs} } OPTIONAL,
30664 struct E_RABs_ToBeSetupRetrieve_Item : asn::sequence<4, 0, true, 2>
30666 static constexpr const char* name() {return "E-RABs-ToBeSetupRetrieve-Item";}
30667 using parent_t = asn::sequence<4, 0, true, 2>;
30668 struct e_RAB_ID_t : E_RAB_ID
30670 static constexpr const char* name() {return "e_RAB_ID_t";}
30671 using parent_t = E_RAB_ID;
30674 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30675 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30676 struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
30678 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
30679 using parent_t = E_RAB_Level_QoS_Parameters;
30682 e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
30683 e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
30684 struct bearerType_t : BearerType
30686 static constexpr const char* name() {return "bearerType_t";}
30687 using parent_t = BearerType;
30688 static constexpr bool optional = true;
30691 bearerType_t& set_bearerType() { bearerType.setpresent(true); return bearerType;}
30692 bearerType_t const* get_bearerType() const {return bearerType.is_valid() ? &bearerType : nullptr;}
30693 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>
30695 static constexpr const char* name() {return "iE_Extensions_t";}
30696 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>;
30697 static constexpr bool optional = true;
30700 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30701 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30702 template<typename V> void decode(V& v)
30705 v(e_RAB_Level_QoS_Parameters);
30710 template<typename V> void encode(V& v) const
30713 v(e_RAB_Level_QoS_Parameters);
30721 e_RAB_Level_QoS_Parameters.clear();
30722 bearerType.clear();
30723 iE_Extensions.clear();
30727 e_RAB_ID_t e_RAB_ID;
30728 e_RAB_Level_QoS_Parameters_t e_RAB_Level_QoS_Parameters;
30729 bearerType_t bearerType;
30730 iE_Extensions_t iE_Extensions;
30734 E-RABs-ToBeSetupRetrieve-ItemIEs X2AP-PROTOCOL-IES ::= {
30735 { ID id-E-RABs-ToBeSetupRetrieve-Item CRITICALITY ignore TYPE E-RABs-ToBeSetupRetrieve-Item PRESENCE mandatory},
30740 struct E_RABs_ToBeSetupRetrieve_ItemIEs
30742 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30744 size_t get_index() const {return type;}
30745 bool is_unknown() const { return type == 2; }
30746 void clear() {type = 0;}
30747 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(id_E_RABs_ToBeSetupRetrieve_Item); type=1;}
30748 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30749 template<typename V> bool decode(V& v)
30752 if(!v(ref_nested())) return false;
30753 if(equal(id_E_RABs_ToBeSetupRetrieve_Item)) { type = 1; return true; }
30754 else { type = 2; return true;}
30758 template<typename V> bool encode(V& v) const
30760 return v(ref_nested());
30764 template<typename V> bool decode(size_t index, V& v)
30769 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeSetupRetrieve_Item);} return false;
30770 case 2: type = 2; return v(ref_nested());
30771 ref_nested().clear();
30776 template<typename V> bool encode(size_t index, V& v) const
30778 if(index != type) {return false;} return v(ref_nested());
30785 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30787 size_t get_index() const {return type;}
30788 bool is_unknown() const { return type == 2; }
30789 void clear() {type = 0;}
30790 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(ignore); type=1;}
30791 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30792 template<typename V> bool decode(V& v)
30795 if(!v(ref_nested())) return false;
30796 if(equal(ignore)) { type = 1; return true; }
30797 else { type = 2; return true;}
30801 template<typename V> bool encode(V& v) const
30803 return v(ref_nested());
30807 template<typename V> bool decode(size_t index, V& v)
30812 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
30813 case 2: type = 2; return v(ref_nested());
30814 ref_nested().clear();
30819 template<typename V> bool encode(size_t index, V& v) const
30821 if(index != type) {return false;} return v(ref_nested());
30828 struct Value_t : asn::typefield<true>
30830 ~Value_t() {clear();}
30831 size_t get_index() const {return type;}
30832 E_RABs_ToBeSetupRetrieve_Item& select_id_E_RABs_ToBeSetupRetrieve_Item() { return set<E_RABs_ToBeSetupRetrieve_Item>(1); }
30833 E_RABs_ToBeSetupRetrieve_Item const* get_id_E_RABs_ToBeSetupRetrieve_Item() const { return get<E_RABs_ToBeSetupRetrieve_Item>(1); }
30834 bool is_unknown() const { return type == 2; }
30839 case 1: var.destroy<E_RABs_ToBeSetupRetrieve_Item>(); break;
30841 type = 0; ref_nested().clear();
30843 template<typename V> static inline void enumerate(V& v)
30845 v.template operator()<E_RABs_ToBeSetupRetrieve_Item>(1);
30849 template<typename V> bool decode(size_t index, V& v)
30854 case 1: v(select_id_E_RABs_ToBeSetupRetrieve_Item()); return true;
30855 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30860 template<typename V> bool encode(size_t index, V& v) const
30862 if(index != type) return false;
30865 case 1: v(var.as<E_RABs_ToBeSetupRetrieve_Item>()); return true;
30871 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30872 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30875 char dummy1[sizeof(E_RABs_ToBeSetupRetrieve_Item)];
30878 asn::variant<sizeof(union_type)> var;
30882 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
30884 size_t get_index() const {return type;}
30885 bool is_unknown() const { return type == 2; }
30886 void clear() {type = 0;}
30887 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(mandatory); type=1;}
30888 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
30889 template<typename V> bool decode(V& v)
30892 if(!v(ref_nested())) return false;
30893 if(equal(mandatory)) { type = 1; return true; }
30894 else { type = 2; return true;}
30898 template<typename V> bool encode(V& v) const
30900 return v(ref_nested());
30904 template<typename V> bool decode(size_t index, V& v)
30909 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30910 case 2: type = 2; return v(ref_nested());
30911 ref_nested().clear();
30916 template<typename V> bool encode(size_t index, V& v) const
30918 if(index != type) {return false;} return v(ref_nested());
30928 E-RABs-ToBeSetup-ListRetrieve ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetupRetrieve-ItemIEs} }
30931 struct E_RABs_ToBeSetup_ListRetrieve_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>
30933 static constexpr const char* name() {return "E_RABs_ToBeSetup_ListRetrieve_elm";}
30934 using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>;
30937 struct E_RABs_ToBeSetup_ListRetrieve : asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>
30939 static constexpr const char* name() {return "E-RABs-ToBeSetup-ListRetrieve";}
30940 using parent_t = asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>;
30941 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
30945 ENB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
30950 struct ENB_ENDCConfigUpdateAckIEs
30952 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30954 size_t get_index() const {return type;}
30955 bool is_unknown() const { return type == 1; }
30956 void clear() {type = 0;}
30957 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30958 template<typename V> bool decode(V& v)
30961 if(!v(ref_nested())) return false;
30962 { type = 1; return true;}
30966 template<typename V> bool encode(V& v) const
30968 return v(ref_nested());
30972 template<typename V> bool decode(size_t index, V& v)
30977 case 1: type = 1; return v(ref_nested());
30978 ref_nested().clear();
30983 template<typename V> bool encode(size_t index, V& v) const
30985 if(index != type) {return false;} return v(ref_nested());
30992 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30994 size_t get_index() const {return type;}
30995 bool is_unknown() const { return type == 1; }
30996 void clear() {type = 0;}
30997 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30998 template<typename V> bool decode(V& v)
31001 if(!v(ref_nested())) return false;
31002 { type = 1; return true;}
31006 template<typename V> bool encode(V& v) const
31008 return v(ref_nested());
31012 template<typename V> bool decode(size_t index, V& v)
31017 case 1: type = 1; return v(ref_nested());
31018 ref_nested().clear();
31023 template<typename V> bool encode(size_t index, V& v) const
31025 if(index != type) {return false;} return v(ref_nested());
31032 struct Value_t : asn::typefield<true>
31034 ~Value_t() {clear();}
31035 size_t get_index() const {return type;}
31036 bool is_unknown() const { return type == 1; }
31039 type = 0; ref_nested().clear();
31041 template<typename V> static inline void enumerate(V& v)
31046 template<typename V> bool decode(size_t index, V& v)
31051 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31056 template<typename V> bool encode(size_t index, V& v) const
31058 if(index != type) return false;
31066 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
31068 size_t get_index() const {return type;}
31069 bool is_unknown() const { return type == 1; }
31070 void clear() {type = 0;}
31071 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
31072 template<typename V> bool decode(V& v)
31075 if(!v(ref_nested())) return false;
31076 { type = 1; return true;}
31080 template<typename V> bool encode(V& v) const
31082 return v(ref_nested());
31086 template<typename V> bool decode(size_t index, V& v)
31091 case 1: type = 1; return v(ref_nested());
31092 ref_nested().clear();
31097 template<typename V> bool encode(size_t index, V& v) const
31099 if(index != type) {return false;} return v(ref_nested());
31109 FDD-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31114 struct FDD_InfoNeighbourServedNRCell_Information_ExtIEs
31116 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31118 size_t get_index() const {return type;}
31119 bool is_unknown() const { return type == 1; }
31120 void clear() {type = 0;}
31121 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31122 template<typename V> bool decode(V& v)
31125 if(!v(ref_nested())) return false;
31126 { type = 1; return true;}
31130 template<typename V> bool encode(V& v) const
31132 return v(ref_nested());
31136 template<typename V> bool decode(size_t index, V& v)
31141 case 1: type = 1; return v(ref_nested());
31142 ref_nested().clear();
31147 template<typename V> bool encode(size_t index, V& v) const
31149 if(index != type) {return false;} return v(ref_nested());
31156 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31158 size_t get_index() const {return type;}
31159 bool is_unknown() const { return type == 1; }
31160 void clear() {type = 0;}
31161 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31162 template<typename V> bool decode(V& v)
31165 if(!v(ref_nested())) return false;
31166 { type = 1; return true;}
31170 template<typename V> bool encode(V& v) const
31172 return v(ref_nested());
31176 template<typename V> bool decode(size_t index, V& v)
31181 case 1: type = 1; return v(ref_nested());
31182 ref_nested().clear();
31187 template<typename V> bool encode(size_t index, V& v) const
31189 if(index != type) {return false;} return v(ref_nested());
31196 struct Extension_t : asn::typefield<true>
31198 ~Extension_t() {clear();}
31199 size_t get_index() const {return type;}
31200 bool is_unknown() const { return type == 1; }
31203 type = 0; ref_nested().clear();
31205 template<typename V> static inline void enumerate(V& v)
31210 template<typename V> bool decode(size_t index, V& v)
31215 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31220 template<typename V> bool encode(size_t index, V& v) const
31222 if(index != type) return false;
31230 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31232 size_t get_index() const {return type;}
31233 bool is_unknown() const { return type == 1; }
31234 void clear() {type = 0;}
31235 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31236 template<typename V> bool decode(V& v)
31239 if(!v(ref_nested())) return false;
31240 { type = 1; return true;}
31244 template<typename V> bool encode(V& v) const
31246 return v(ref_nested());
31250 template<typename V> bool decode(size_t index, V& v)
31255 case 1: type = 1; return v(ref_nested());
31256 ref_nested().clear();
31261 template<typename V> bool encode(size_t index, V& v) const
31263 if(index != type) {return false;} return v(ref_nested());
31273 FDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
31274 ul-NRFreqInfo NRFreqInfo,
31275 dl-NRFreqInfo NRFreqInfo,
31276 iE-Extensions ProtocolExtensionContainer { {FDD-InfoNeighbourServedNRCell-Information-ExtIEs} } OPTIONAL,
31281 struct FDD_InfoNeighbourServedNRCell_Information : asn::sequence<3, 0, true, 1>
31283 static constexpr const char* name() {return "FDD-InfoNeighbourServedNRCell-Information";}
31284 using parent_t = asn::sequence<3, 0, true, 1>;
31285 struct ul_NRFreqInfo_t : NRFreqInfo
31287 static constexpr const char* name() {return "ul_NRFreqInfo_t";}
31288 using parent_t = NRFreqInfo;
31291 ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
31292 ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
31293 struct dl_NRFreqInfo_t : NRFreqInfo
31295 static constexpr const char* name() {return "dl_NRFreqInfo_t";}
31296 using parent_t = NRFreqInfo;
31299 dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
31300 dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
31301 struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_Information_ExtIEs>
31303 static constexpr const char* name() {return "iE_Extensions_t";}
31304 using parent_t = ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_Information_ExtIEs>;
31305 static constexpr bool optional = true;
31308 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31309 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31310 template<typename V> void decode(V& v)
31317 template<typename V> void encode(V& v) const
31326 ul_NRFreqInfo.clear();
31327 dl_NRFreqInfo.clear();
31328 iE_Extensions.clear();
31332 ul_NRFreqInfo_t ul_NRFreqInfo;
31333 dl_NRFreqInfo_t dl_NRFreqInfo;
31334 iE_Extensions_t iE_Extensions;
31338 TDD-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31343 struct TDD_InfoNeighbourServedNRCell_Information_ExtIEs
31345 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31347 size_t get_index() const {return type;}
31348 bool is_unknown() const { return type == 1; }
31349 void clear() {type = 0;}
31350 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31351 template<typename V> bool decode(V& v)
31354 if(!v(ref_nested())) return false;
31355 { type = 1; return true;}
31359 template<typename V> bool encode(V& v) const
31361 return v(ref_nested());
31365 template<typename V> bool decode(size_t index, V& v)
31370 case 1: type = 1; return v(ref_nested());
31371 ref_nested().clear();
31376 template<typename V> bool encode(size_t index, V& v) const
31378 if(index != type) {return false;} return v(ref_nested());
31385 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31387 size_t get_index() const {return type;}
31388 bool is_unknown() const { return type == 1; }
31389 void clear() {type = 0;}
31390 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31391 template<typename V> bool decode(V& v)
31394 if(!v(ref_nested())) return false;
31395 { type = 1; return true;}
31399 template<typename V> bool encode(V& v) const
31401 return v(ref_nested());
31405 template<typename V> bool decode(size_t index, V& v)
31410 case 1: type = 1; return v(ref_nested());
31411 ref_nested().clear();
31416 template<typename V> bool encode(size_t index, V& v) const
31418 if(index != type) {return false;} return v(ref_nested());
31425 struct Extension_t : asn::typefield<true>
31427 ~Extension_t() {clear();}
31428 size_t get_index() const {return type;}
31429 bool is_unknown() const { return type == 1; }
31432 type = 0; ref_nested().clear();
31434 template<typename V> static inline void enumerate(V& v)
31439 template<typename V> bool decode(size_t index, V& v)
31444 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31449 template<typename V> bool encode(size_t index, V& v) const
31451 if(index != type) return false;
31459 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31461 size_t get_index() const {return type;}
31462 bool is_unknown() const { return type == 1; }
31463 void clear() {type = 0;}
31464 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31465 template<typename V> bool decode(V& v)
31468 if(!v(ref_nested())) return false;
31469 { type = 1; return true;}
31473 template<typename V> bool encode(V& v) const
31475 return v(ref_nested());
31479 template<typename V> bool decode(size_t index, V& v)
31484 case 1: type = 1; return v(ref_nested());
31485 ref_nested().clear();
31490 template<typename V> bool encode(size_t index, V& v) const
31492 if(index != type) {return false;} return v(ref_nested());
31502 TDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
31503 nRFreqInfo NRFreqInfo,
31504 iE-Extensions ProtocolExtensionContainer { {TDD-InfoNeighbourServedNRCell-Information-ExtIEs} } OPTIONAL,
31509 struct TDD_InfoNeighbourServedNRCell_Information : asn::sequence<2, 0, true, 1>
31511 static constexpr const char* name() {return "TDD-InfoNeighbourServedNRCell-Information";}
31512 using parent_t = asn::sequence<2, 0, true, 1>;
31513 struct nRFreqInfo_t : NRFreqInfo
31515 static constexpr const char* name() {return "nRFreqInfo_t";}
31516 using parent_t = NRFreqInfo;
31519 nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
31520 nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
31521 struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_Information_ExtIEs>
31523 static constexpr const char* name() {return "iE_Extensions_t";}
31524 using parent_t = ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_Information_ExtIEs>;
31525 static constexpr bool optional = true;
31528 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31529 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31530 template<typename V> void decode(V& v)
31536 template<typename V> void encode(V& v) const
31544 nRFreqInfo.clear();
31545 iE_Extensions.clear();
31549 nRFreqInfo_t nRFreqInfo;
31550 iE_Extensions_t iE_Extensions;
31554 NRNeighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31559 struct NRNeighbour_Information_ExtIEs
31561 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31563 size_t get_index() const {return type;}
31564 bool is_unknown() const { return type == 1; }
31565 void clear() {type = 0;}
31566 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31567 template<typename V> bool decode(V& v)
31570 if(!v(ref_nested())) return false;
31571 { type = 1; return true;}
31575 template<typename V> bool encode(V& v) const
31577 return v(ref_nested());
31581 template<typename V> bool decode(size_t index, V& v)
31586 case 1: type = 1; return v(ref_nested());
31587 ref_nested().clear();
31592 template<typename V> bool encode(size_t index, V& v) const
31594 if(index != type) {return false;} return v(ref_nested());
31601 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31603 size_t get_index() const {return type;}
31604 bool is_unknown() const { return type == 1; }
31605 void clear() {type = 0;}
31606 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31607 template<typename V> bool decode(V& v)
31610 if(!v(ref_nested())) return false;
31611 { type = 1; return true;}
31615 template<typename V> bool encode(V& v) const
31617 return v(ref_nested());
31621 template<typename V> bool decode(size_t index, V& v)
31626 case 1: type = 1; return v(ref_nested());
31627 ref_nested().clear();
31632 template<typename V> bool encode(size_t index, V& v) const
31634 if(index != type) {return false;} return v(ref_nested());
31641 struct Extension_t : asn::typefield<true>
31643 ~Extension_t() {clear();}
31644 size_t get_index() const {return type;}
31645 bool is_unknown() const { return type == 1; }
31648 type = 0; ref_nested().clear();
31650 template<typename V> static inline void enumerate(V& v)
31655 template<typename V> bool decode(size_t index, V& v)
31660 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31665 template<typename V> bool encode(size_t index, V& v) const
31667 if(index != type) return false;
31675 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31677 size_t get_index() const {return type;}
31678 bool is_unknown() const { return type == 1; }
31679 void clear() {type = 0;}
31680 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31681 template<typename V> bool decode(V& v)
31684 if(!v(ref_nested())) return false;
31685 { type = 1; 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; return v(ref_nested());
31701 ref_nested().clear();
31706 template<typename V> bool encode(size_t index, V& v) const
31708 if(index != type) {return false;} return v(ref_nested());
31718 NRNeighbour-Information ::= SEQUENCE (SIZE (1.. maxofNRNeighbours))OF SEQUENCE {
31721 fiveGS-TAC FiveGS-TAC OPTIONAL,
31722 configured-TAC TAC OPTIONAL,
31723 measurementTimingConfiguration OCTET STRING,
31724 nRNeighbourModeInfo CHOICE {
31725 fdd FDD-InfoNeighbourServedNRCell-Information,
31726 tdd TDD-InfoNeighbourServedNRCell-Information,
31729 iE-Extensions ProtocolExtensionContainer { {NRNeighbour-Information-ExtIEs} } OPTIONAL,
31734 struct NRNeighbour_Information_elm : asn::sequence<7, 0, true, 3>
31736 static constexpr const char* name() {return "NRNeighbour_Information_elm";}
31737 using parent_t = asn::sequence<7, 0, true, 3>;
31738 struct nrpCI_t : NRPCI
31740 static constexpr const char* name() {return "nrpCI_t";}
31741 using parent_t = NRPCI;
31744 nrpCI_t& ref_nrpCI() {return nrpCI;}
31745 nrpCI_t const& ref_nrpCI() const {return nrpCI;}
31746 struct nrCellID_t : NRCGI
31748 static constexpr const char* name() {return "nrCellID_t";}
31749 using parent_t = NRCGI;
31752 nrCellID_t& ref_nrCellID() {return nrCellID;}
31753 nrCellID_t const& ref_nrCellID() const {return nrCellID;}
31754 struct fiveGS_TAC_t : FiveGS_TAC
31756 static constexpr const char* name() {return "fiveGS_TAC_t";}
31757 using parent_t = FiveGS_TAC;
31758 static constexpr bool optional = true;
31761 fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
31762 fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
31763 struct configured_TAC_t : TAC
31765 static constexpr const char* name() {return "configured_TAC_t";}
31766 using parent_t = TAC;
31767 static constexpr bool optional = true;
31770 configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
31771 configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
31772 struct measurementTimingConfiguration_t : asn::ostring<>
31774 static constexpr const char* name() {return "measurementTimingConfiguration_t";}
31775 using parent_t = asn::ostring<>;
31779 measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
31780 measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
31781 struct nRNeighbourModeInfo_t : asn::choice<2, 0, true>
31783 static constexpr const char* name() {return "nRNeighbourModeInfo_t";}
31784 using parent_t = asn::choice<2, 0, true>;
31785 index_type get_index() const {return index;}
31786 bool is_unknown() const {return index == 3;}
31787 void set_unknown() { set_index(3); }
31788 ~nRNeighbourModeInfo_t() {clear();}
31789 struct fdd_t : FDD_InfoNeighbourServedNRCell_Information
31791 static constexpr const char* name() {return "fdd_t";}
31792 using parent_t = FDD_InfoNeighbourServedNRCell_Information;
31795 struct tdd_t : TDD_InfoNeighbourServedNRCell_Information
31797 static constexpr const char* name() {return "tdd_t";}
31798 using parent_t = TDD_InfoNeighbourServedNRCell_Information;
31803 switch(get_index())
31805 case 1: var.destroy<fdd_t>(); break;
31806 case 2: var.destroy<tdd_t>(); break;
31811 template<typename V> bool decode(size_t idx, V& v)
31816 case 1: set_index(1); return v(var.build<fdd_t>());
31817 case 2: set_index(2); return v(var.build<tdd_t>());
31822 template<typename V> bool encode(V& v) const
31824 switch(get_index())
31826 case 1: return v(var.as<fdd_t>());
31827 case 2: return v(var.as<tdd_t>());
31831 template<typename V> static inline void enumerate(V& v)
31833 v.template operator()<fdd_t>(1);
31834 v.template operator()<tdd_t>(2);
31837 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
31838 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
31839 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
31840 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
31842 void set_index(index_type i) {index = i; base::set();}
31845 char dummy1[sizeof(fdd_t)];
31846 char dummy2[sizeof(tdd_t)];
31849 asn::variant<sizeof(union_type)> var;
31850 index_type index {0};
31852 nRNeighbourModeInfo_t& ref_nRNeighbourModeInfo() {return nRNeighbourModeInfo;}
31853 nRNeighbourModeInfo_t const& ref_nRNeighbourModeInfo() const {return nRNeighbourModeInfo;}
31854 struct iE_Extensions_t : ProtocolExtensionContainer<NRNeighbour_Information_ExtIEs>
31856 static constexpr const char* name() {return "iE_Extensions_t";}
31857 using parent_t = ProtocolExtensionContainer<NRNeighbour_Information_ExtIEs>;
31858 static constexpr bool optional = true;
31861 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31862 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31863 template<typename V> void decode(V& v)
31869 v(measurementTimingConfiguration);
31870 v(nRNeighbourModeInfo);
31874 template<typename V> void encode(V& v) const
31880 v(measurementTimingConfiguration);
31881 v(nRNeighbourModeInfo);
31889 fiveGS_TAC.clear();
31890 configured_TAC.clear();
31891 measurementTimingConfiguration.clear();
31892 nRNeighbourModeInfo.clear();
31893 iE_Extensions.clear();
31898 nrCellID_t nrCellID;
31899 fiveGS_TAC_t fiveGS_TAC;
31900 configured_TAC_t configured_TAC;
31901 measurementTimingConfiguration_t measurementTimingConfiguration;
31902 nRNeighbourModeInfo_t nRNeighbourModeInfo;
31903 iE_Extensions_t iE_Extensions;
31906 struct NRNeighbour_Information : asn::sequenceof<NRNeighbour_Information_elm>
31908 static constexpr const char* name() {return "NRNeighbour-Information";}
31909 using parent_t = asn::sequenceof<NRNeighbour_Information_elm>;
31910 using constraint_t = asn::constraints<false,asn::span<1, maxofNRNeighbours >>;
31914 ServedEUTRAcellsENDCX2Management-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31919 struct ServedEUTRAcellsENDCX2Management_ExtIEs
31921 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31923 size_t get_index() const {return type;}
31924 bool is_unknown() const { return type == 1; }
31925 void clear() {type = 0;}
31926 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31927 template<typename V> bool decode(V& v)
31930 if(!v(ref_nested())) return false;
31931 { type = 1; return true;}
31935 template<typename V> bool encode(V& v) const
31937 return v(ref_nested());
31941 template<typename V> bool decode(size_t index, V& v)
31946 case 1: type = 1; return v(ref_nested());
31947 ref_nested().clear();
31952 template<typename V> bool encode(size_t index, V& v) const
31954 if(index != type) {return false;} return v(ref_nested());
31961 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31963 size_t get_index() const {return type;}
31964 bool is_unknown() const { return type == 1; }
31965 void clear() {type = 0;}
31966 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31967 template<typename V> bool decode(V& v)
31970 if(!v(ref_nested())) return false;
31971 { type = 1; return true;}
31975 template<typename V> bool encode(V& v) const
31977 return v(ref_nested());
31981 template<typename V> bool decode(size_t index, V& v)
31986 case 1: type = 1; return v(ref_nested());
31987 ref_nested().clear();
31992 template<typename V> bool encode(size_t index, V& v) const
31994 if(index != type) {return false;} return v(ref_nested());
32001 struct Extension_t : asn::typefield<true>
32003 ~Extension_t() {clear();}
32004 size_t get_index() const {return type;}
32005 bool is_unknown() const { return type == 1; }
32008 type = 0; ref_nested().clear();
32010 template<typename V> static inline void enumerate(V& v)
32015 template<typename V> bool decode(size_t index, V& v)
32020 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32025 template<typename V> bool encode(size_t index, V& v) const
32027 if(index != type) return false;
32035 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32037 size_t get_index() const {return type;}
32038 bool is_unknown() const { return type == 1; }
32039 void clear() {type = 0;}
32040 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32041 template<typename V> bool decode(V& v)
32044 if(!v(ref_nested())) return false;
32045 { type = 1; return true;}
32049 template<typename V> bool encode(V& v) const
32051 return v(ref_nested());
32055 template<typename V> bool decode(size_t index, V& v)
32060 case 1: type = 1; return v(ref_nested());
32061 ref_nested().clear();
32066 template<typename V> bool encode(size_t index, V& v) const
32068 if(index != type) {return false;} return v(ref_nested());
32078 ServedEUTRAcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
32079 servedEUTRACellInfo ServedCell-Information,
32080 nrNeighbourInfo NRNeighbour-Information OPTIONAL,
32081 iE-Extensions ProtocolExtensionContainer { {ServedEUTRAcellsENDCX2Management-ExtIEs} } OPTIONAL,
32086 struct ServedEUTRAcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
32088 static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList_elm";}
32089 using parent_t = asn::sequence<3, 0, true, 2>;
32090 struct servedEUTRACellInfo_t : ServedCell_Information
32092 static constexpr const char* name() {return "servedEUTRACellInfo_t";}
32093 using parent_t = ServedCell_Information;
32096 servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
32097 servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
32098 struct nrNeighbourInfo_t : NRNeighbour_Information
32100 static constexpr const char* name() {return "nrNeighbourInfo_t";}
32101 using parent_t = NRNeighbour_Information;
32102 static constexpr bool optional = true;
32105 nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
32106 nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
32107 struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_ExtIEs>
32109 static constexpr const char* name() {return "iE_Extensions_t";}
32110 using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_ExtIEs>;
32111 static constexpr bool optional = true;
32114 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32115 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32116 template<typename V> void decode(V& v)
32118 v(servedEUTRACellInfo);
32119 v(nrNeighbourInfo);
32123 template<typename V> void encode(V& v) const
32125 v(servedEUTRACellInfo);
32126 v(nrNeighbourInfo);
32132 servedEUTRACellInfo.clear();
32133 nrNeighbourInfo.clear();
32134 iE_Extensions.clear();
32138 servedEUTRACellInfo_t servedEUTRACellInfo;
32139 nrNeighbourInfo_t nrNeighbourInfo;
32140 iE_Extensions_t iE_Extensions;
32143 struct ServedEUTRAcellsENDCX2ManagementList : asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>
32145 static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList";}
32146 using parent_t = asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>;
32147 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
32151 ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32156 struct ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs
32158 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32160 size_t get_index() const {return type;}
32161 bool is_unknown() const { return type == 1; }
32162 void clear() {type = 0;}
32163 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32164 template<typename V> bool decode(V& v)
32167 if(!v(ref_nested())) return false;
32168 { type = 1; return true;}
32172 template<typename V> bool encode(V& v) const
32174 return v(ref_nested());
32178 template<typename V> bool decode(size_t index, V& v)
32183 case 1: type = 1; return v(ref_nested());
32184 ref_nested().clear();
32189 template<typename V> bool encode(size_t index, V& v) const
32191 if(index != type) {return false;} return v(ref_nested());
32198 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32200 size_t get_index() const {return type;}
32201 bool is_unknown() const { return type == 1; }
32202 void clear() {type = 0;}
32203 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32204 template<typename V> bool decode(V& v)
32207 if(!v(ref_nested())) return false;
32208 { type = 1; return true;}
32212 template<typename V> bool encode(V& v) const
32214 return v(ref_nested());
32218 template<typename V> bool decode(size_t index, V& v)
32223 case 1: type = 1; return v(ref_nested());
32224 ref_nested().clear();
32229 template<typename V> bool encode(size_t index, V& v) const
32231 if(index != type) {return false;} return v(ref_nested());
32238 struct Extension_t : asn::typefield<true>
32240 ~Extension_t() {clear();}
32241 size_t get_index() const {return type;}
32242 bool is_unknown() const { return type == 1; }
32245 type = 0; ref_nested().clear();
32247 template<typename V> static inline void enumerate(V& v)
32252 template<typename V> bool decode(size_t index, V& v)
32257 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32262 template<typename V> bool encode(size_t index, V& v) const
32264 if(index != type) return false;
32272 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32274 size_t get_index() const {return type;}
32275 bool is_unknown() const { return type == 1; }
32276 void clear() {type = 0;}
32277 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32278 template<typename V> bool decode(V& v)
32281 if(!v(ref_nested())) return false;
32282 { type = 1; return true;}
32286 template<typename V> bool encode(V& v) const
32288 return v(ref_nested());
32292 template<typename V> bool decode(size_t index, V& v)
32297 case 1: type = 1; return v(ref_nested());
32298 ref_nested().clear();
32303 template<typename V> bool encode(size_t index, V& v) const
32305 if(index != type) {return false;} return v(ref_nested());
32315 ServedEUTRAcellsToModifyListENDCConfUpd ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
32317 servedEUTRACellInfo ServedCell-Information,
32318 nrNeighbourInfo NRNeighbour-Information OPTIONAL,
32319 iE-Extensions ProtocolExtensionContainer { {ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs} } OPTIONAL,
32324 struct ServedEUTRAcellsToModifyListENDCConfUpd_elm : asn::sequence<4, 0, true, 2>
32326 static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd_elm";}
32327 using parent_t = asn::sequence<4, 0, true, 2>;
32328 struct old_ECGI_t : ECGI
32330 static constexpr const char* name() {return "old_ECGI_t";}
32331 using parent_t = ECGI;
32334 old_ECGI_t& ref_old_ECGI() {return old_ECGI;}
32335 old_ECGI_t const& ref_old_ECGI() const {return old_ECGI;}
32336 struct servedEUTRACellInfo_t : ServedCell_Information
32338 static constexpr const char* name() {return "servedEUTRACellInfo_t";}
32339 using parent_t = ServedCell_Information;
32342 servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
32343 servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
32344 struct nrNeighbourInfo_t : NRNeighbour_Information
32346 static constexpr const char* name() {return "nrNeighbourInfo_t";}
32347 using parent_t = NRNeighbour_Information;
32348 static constexpr bool optional = true;
32351 nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
32352 nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
32353 struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs>
32355 static constexpr const char* name() {return "iE_Extensions_t";}
32356 using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs>;
32357 static constexpr bool optional = true;
32360 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32361 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32362 template<typename V> void decode(V& v)
32365 v(servedEUTRACellInfo);
32366 v(nrNeighbourInfo);
32370 template<typename V> void encode(V& v) const
32373 v(servedEUTRACellInfo);
32374 v(nrNeighbourInfo);
32381 servedEUTRACellInfo.clear();
32382 nrNeighbourInfo.clear();
32383 iE_Extensions.clear();
32387 old_ECGI_t old_ECGI;
32388 servedEUTRACellInfo_t servedEUTRACellInfo;
32389 nrNeighbourInfo_t nrNeighbourInfo;
32390 iE_Extensions_t iE_Extensions;
32393 struct ServedEUTRAcellsToModifyListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>
32395 static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd";}
32396 using parent_t = asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>;
32397 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
32401 ServedEUTRAcellsToDeleteListENDCConfUpd ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
32404 struct ServedEUTRAcellsToDeleteListENDCConfUpd_elm : ECGI
32406 static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd_elm";}
32407 using parent_t = ECGI;
32410 struct ServedEUTRAcellsToDeleteListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>
32412 static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd";}
32413 using parent_t = asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>;
32414 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
32418 ENB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
32419 { ID id-CellAssistanceInformation CRITICALITY reject TYPE CellAssistanceInformation PRESENCE optional }|
32420 { ID id-ServedEUTRAcellsENDCX2ManagementList CRITICALITY reject TYPE ServedEUTRAcellsENDCX2ManagementList PRESENCE optional }|
32421 { ID id-ServedEUTRAcellsToModifyListENDCConfUpd CRITICALITY reject TYPE ServedEUTRAcellsToModifyListENDCConfUpd PRESENCE optional }|
32422 { ID id-ServedEUTRAcellsToDeleteListENDCConfUpd CRITICALITY reject TYPE ServedEUTRAcellsToDeleteListENDCConfUpd PRESENCE optional },
32427 struct ENB_ENDCConfigUpdateIEs
32429 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32431 size_t get_index() const {return type;}
32432 bool is_unknown() const { return type == 5; }
32433 void clear() {type = 0;}
32434 void select_id_CellAssistanceInformation() { set(id_CellAssistanceInformation); type=1;}
32435 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
32436 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(id_ServedEUTRAcellsToModifyListENDCConfUpd); type=3;}
32437 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(id_ServedEUTRAcellsToDeleteListENDCConfUpd); type=4;}
32438 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32439 template<typename V> bool decode(V& v)
32442 if(!v(ref_nested())) return false;
32443 if(equal(id_CellAssistanceInformation)) { type = 1; return true; }
32444 else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
32445 else if(equal(id_ServedEUTRAcellsToModifyListENDCConfUpd)) { type = 3; return true; }
32446 else if(equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd)) { type = 4; return true; }
32447 else { type = 5; return true;}
32451 template<typename V> bool encode(V& v) const
32453 return v(ref_nested());
32457 template<typename V> bool decode(size_t index, V& v)
32462 case 1: type = 1; if(v(ref_nested())) { return equal(id_CellAssistanceInformation);} return false;
32463 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
32464 case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToModifyListENDCConfUpd);} return false;
32465 case 4: type = 4; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd);} return false;
32466 case 5: type = 5; return v(ref_nested());
32467 ref_nested().clear();
32472 template<typename V> bool encode(size_t index, V& v) const
32474 if(index != type) {return false;} return v(ref_nested());
32481 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32483 size_t get_index() const {return type;}
32484 bool is_unknown() const { return type == 5; }
32485 void clear() {type = 0;}
32486 void select_id_CellAssistanceInformation() { set(reject); type=1;}
32487 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
32488 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(reject); type=3;}
32489 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(reject); type=4;}
32490 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32491 template<typename V> bool decode(V& v)
32494 if(!v(ref_nested())) return false;
32495 if(equal(reject)) { type = 1; return true; }
32496 else if(equal(reject)) { type = 2; return true; }
32497 else if(equal(reject)) { type = 3; return true; }
32498 else if(equal(reject)) { type = 4; return true; }
32499 else { type = 5; return true;}
32503 template<typename V> bool encode(V& v) const
32505 return v(ref_nested());
32509 template<typename V> bool decode(size_t index, V& v)
32514 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32515 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
32516 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
32517 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
32518 case 5: type = 5; return v(ref_nested());
32519 ref_nested().clear();
32524 template<typename V> bool encode(size_t index, V& v) const
32526 if(index != type) {return false;} return v(ref_nested());
32533 struct Value_t : asn::typefield<true>
32535 ~Value_t() {clear();}
32536 size_t get_index() const {return type;}
32537 CellAssistanceInformation& select_id_CellAssistanceInformation() { return set<CellAssistanceInformation>(1); }
32538 CellAssistanceInformation const* get_id_CellAssistanceInformation() const { return get<CellAssistanceInformation>(1); }
32539 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
32540 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
32541 ServedEUTRAcellsToModifyListENDCConfUpd& select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { return set<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
32542 ServedEUTRAcellsToModifyListENDCConfUpd const* get_id_ServedEUTRAcellsToModifyListENDCConfUpd() const { return get<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
32543 ServedEUTRAcellsToDeleteListENDCConfUpd& select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { return set<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
32544 ServedEUTRAcellsToDeleteListENDCConfUpd const* get_id_ServedEUTRAcellsToDeleteListENDCConfUpd() const { return get<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
32545 bool is_unknown() const { return type == 5; }
32550 case 1: var.destroy<CellAssistanceInformation>(); break;
32551 case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
32552 case 3: var.destroy<ServedEUTRAcellsToModifyListENDCConfUpd>(); break;
32553 case 4: var.destroy<ServedEUTRAcellsToDeleteListENDCConfUpd>(); break;
32555 type = 0; ref_nested().clear();
32557 template<typename V> static inline void enumerate(V& v)
32559 v.template operator()<CellAssistanceInformation>(1);
32560 v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
32561 v.template operator()<ServedEUTRAcellsToModifyListENDCConfUpd>(3);
32562 v.template operator()<ServedEUTRAcellsToDeleteListENDCConfUpd>(4);
32566 template<typename V> bool decode(size_t index, V& v)
32571 case 1: v(select_id_CellAssistanceInformation()); return true;
32572 case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
32573 case 3: v(select_id_ServedEUTRAcellsToModifyListENDCConfUpd()); return true;
32574 case 4: v(select_id_ServedEUTRAcellsToDeleteListENDCConfUpd()); return true;
32575 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
32580 template<typename V> bool encode(size_t index, V& v) const
32582 if(index != type) return false;
32585 case 1: v(var.as<CellAssistanceInformation>()); return true;
32586 case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
32587 case 3: v(var.as<ServedEUTRAcellsToModifyListENDCConfUpd>()); return true;
32588 case 4: v(var.as<ServedEUTRAcellsToDeleteListENDCConfUpd>()); return true;
32594 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32595 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32598 char dummy1[sizeof(CellAssistanceInformation)];
32599 char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
32600 char dummy3[sizeof(ServedEUTRAcellsToDeleteListENDCConfUpd)];
32601 char dummy4[sizeof(ServedEUTRAcellsToModifyListENDCConfUpd)];
32604 asn::variant<sizeof(union_type)> var;
32608 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
32610 size_t get_index() const {return type;}
32611 bool is_unknown() const { return type == 5; }
32612 void clear() {type = 0;}
32613 void select_id_CellAssistanceInformation() { set(optional); type=1;}
32614 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(optional); type=2;}
32615 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(optional); type=3;}
32616 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(optional); type=4;}
32617 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
32618 template<typename V> bool decode(V& v)
32621 if(!v(ref_nested())) return false;
32622 if(equal(optional)) { type = 1; return true; }
32623 else if(equal(optional)) { type = 2; return true; }
32624 else if(equal(optional)) { type = 3; return true; }
32625 else if(equal(optional)) { type = 4; return true; }
32626 else { type = 5; return true;}
32630 template<typename V> bool encode(V& v) const
32632 return v(ref_nested());
32636 template<typename V> bool decode(size_t index, V& v)
32641 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
32642 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
32643 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
32644 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
32645 case 5: type = 5; return v(ref_nested());
32646 ref_nested().clear();
32651 template<typename V> bool encode(size_t index, V& v) const
32653 if(index != type) {return false;} return v(ref_nested());
32663 ENB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
32664 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory},
32669 struct ENB_ENDCX2RemovalReqAckIEs
32671 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32673 size_t get_index() const {return type;}
32674 bool is_unknown() const { return type == 2; }
32675 void clear() {type = 0;}
32676 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
32677 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32678 template<typename V> bool decode(V& v)
32681 if(!v(ref_nested())) return false;
32682 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
32683 else { type = 2; return true;}
32687 template<typename V> bool encode(V& v) const
32689 return v(ref_nested());
32693 template<typename V> bool decode(size_t index, V& v)
32698 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
32699 case 2: type = 2; return v(ref_nested());
32700 ref_nested().clear();
32705 template<typename V> bool encode(size_t index, V& v) const
32707 if(index != type) {return false;} return v(ref_nested());
32714 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32716 size_t get_index() const {return type;}
32717 bool is_unknown() const { return type == 2; }
32718 void clear() {type = 0;}
32719 void select_id_GlobalENB_ID() { set(reject); type=1;}
32720 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32721 template<typename V> bool decode(V& v)
32724 if(!v(ref_nested())) return false;
32725 if(equal(reject)) { type = 1; return true; }
32726 else { type = 2; return true;}
32730 template<typename V> bool encode(V& v) const
32732 return v(ref_nested());
32736 template<typename V> bool decode(size_t index, V& v)
32741 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32742 case 2: type = 2; return v(ref_nested());
32743 ref_nested().clear();
32748 template<typename V> bool encode(size_t index, V& v) const
32750 if(index != type) {return false;} return v(ref_nested());
32757 struct Value_t : asn::typefield<true>
32759 ~Value_t() {clear();}
32760 size_t get_index() const {return type;}
32761 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
32762 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
32763 bool is_unknown() const { return type == 2; }
32768 case 1: var.destroy<GlobalENB_ID>(); break;
32770 type = 0; ref_nested().clear();
32772 template<typename V> static inline void enumerate(V& v)
32774 v.template operator()<GlobalENB_ID>(1);
32778 template<typename V> bool decode(size_t index, V& v)
32783 case 1: v(select_id_GlobalENB_ID()); return true;
32784 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
32789 template<typename V> bool encode(size_t index, V& v) const
32791 if(index != type) return false;
32794 case 1: v(var.as<GlobalENB_ID>()); return true;
32800 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32801 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32804 char dummy1[sizeof(GlobalENB_ID)];
32807 asn::variant<sizeof(union_type)> var;
32811 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
32813 size_t get_index() const {return type;}
32814 bool is_unknown() const { return type == 2; }
32815 void clear() {type = 0;}
32816 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
32817 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
32818 template<typename V> bool decode(V& v)
32821 if(!v(ref_nested())) return false;
32822 if(equal(mandatory)) { type = 1; return true; }
32823 else { type = 2; return true;}
32827 template<typename V> bool encode(V& v) const
32829 return v(ref_nested());
32833 template<typename V> bool decode(size_t index, V& v)
32838 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
32839 case 2: type = 2; return v(ref_nested());
32840 ref_nested().clear();
32845 template<typename V> bool encode(size_t index, V& v) const
32847 if(index != type) {return false;} return v(ref_nested());
32857 ENB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
32858 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory},
32863 struct ENB_ENDCX2RemovalReqIEs
32865 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32867 size_t get_index() const {return type;}
32868 bool is_unknown() const { return type == 2; }
32869 void clear() {type = 0;}
32870 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
32871 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32872 template<typename V> bool decode(V& v)
32875 if(!v(ref_nested())) return false;
32876 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
32877 else { type = 2; return true;}
32881 template<typename V> bool encode(V& v) const
32883 return v(ref_nested());
32887 template<typename V> bool decode(size_t index, V& v)
32892 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
32893 case 2: type = 2; return v(ref_nested());
32894 ref_nested().clear();
32899 template<typename V> bool encode(size_t index, V& v) const
32901 if(index != type) {return false;} return v(ref_nested());
32908 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32910 size_t get_index() const {return type;}
32911 bool is_unknown() const { return type == 2; }
32912 void clear() {type = 0;}
32913 void select_id_GlobalENB_ID() { set(reject); type=1;}
32914 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32915 template<typename V> bool decode(V& v)
32918 if(!v(ref_nested())) return false;
32919 if(equal(reject)) { type = 1; return true; }
32920 else { type = 2; return true;}
32924 template<typename V> bool encode(V& v) const
32926 return v(ref_nested());
32930 template<typename V> bool decode(size_t index, V& v)
32935 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32936 case 2: type = 2; return v(ref_nested());
32937 ref_nested().clear();
32942 template<typename V> bool encode(size_t index, V& v) const
32944 if(index != type) {return false;} return v(ref_nested());
32951 struct Value_t : asn::typefield<true>
32953 ~Value_t() {clear();}
32954 size_t get_index() const {return type;}
32955 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
32956 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
32957 bool is_unknown() const { return type == 2; }
32962 case 1: var.destroy<GlobalENB_ID>(); break;
32964 type = 0; ref_nested().clear();
32966 template<typename V> static inline void enumerate(V& v)
32968 v.template operator()<GlobalENB_ID>(1);
32972 template<typename V> bool decode(size_t index, V& v)
32977 case 1: v(select_id_GlobalENB_ID()); return true;
32978 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
32983 template<typename V> bool encode(size_t index, V& v) const
32985 if(index != type) return false;
32988 case 1: v(var.as<GlobalENB_ID>()); return true;
32994 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32995 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32998 char dummy1[sizeof(GlobalENB_ID)];
33001 asn::variant<sizeof(union_type)> var;
33005 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33007 size_t get_index() const {return type;}
33008 bool is_unknown() const { return type == 2; }
33009 void clear() {type = 0;}
33010 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33011 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33012 template<typename V> bool decode(V& v)
33015 if(!v(ref_nested())) return false;
33016 if(equal(mandatory)) { type = 1; return true; }
33017 else { type = 2; return true;}
33021 template<typename V> bool encode(V& v) const
33023 return v(ref_nested());
33027 template<typename V> bool decode(size_t index, V& v)
33032 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33033 case 2: type = 2; return v(ref_nested());
33034 ref_nested().clear();
33039 template<typename V> bool encode(size_t index, V& v) const
33041 if(index != type) {return false;} return v(ref_nested());
33051 ENB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
33052 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
33053 { ID id-ServedEUTRAcellsENDCX2ManagementList CRITICALITY reject TYPE ServedEUTRAcellsENDCX2ManagementList PRESENCE mandatory},
33058 struct ENB_ENDCX2SetupReqAckIEs
33060 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33062 size_t get_index() const {return type;}
33063 bool is_unknown() const { return type == 3; }
33064 void clear() {type = 0;}
33065 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
33066 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
33067 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33068 template<typename V> bool decode(V& v)
33071 if(!v(ref_nested())) return false;
33072 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
33073 else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
33074 else { type = 3; return true;}
33078 template<typename V> bool encode(V& v) const
33080 return v(ref_nested());
33084 template<typename V> bool decode(size_t index, V& v)
33089 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
33090 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
33091 case 3: type = 3; return v(ref_nested());
33092 ref_nested().clear();
33097 template<typename V> bool encode(size_t index, V& v) const
33099 if(index != type) {return false;} return v(ref_nested());
33106 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33108 size_t get_index() const {return type;}
33109 bool is_unknown() const { return type == 3; }
33110 void clear() {type = 0;}
33111 void select_id_GlobalENB_ID() { set(reject); type=1;}
33112 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
33113 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33114 template<typename V> bool decode(V& v)
33117 if(!v(ref_nested())) return false;
33118 if(equal(reject)) { type = 1; return true; }
33119 else if(equal(reject)) { type = 2; return true; }
33120 else { type = 3; return true;}
33124 template<typename V> bool encode(V& v) const
33126 return v(ref_nested());
33130 template<typename V> bool decode(size_t index, V& v)
33135 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33136 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33137 case 3: type = 3; return v(ref_nested());
33138 ref_nested().clear();
33143 template<typename V> bool encode(size_t index, V& v) const
33145 if(index != type) {return false;} return v(ref_nested());
33152 struct Value_t : asn::typefield<true>
33154 ~Value_t() {clear();}
33155 size_t get_index() const {return type;}
33156 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
33157 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
33158 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
33159 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
33160 bool is_unknown() const { return type == 3; }
33165 case 1: var.destroy<GlobalENB_ID>(); break;
33166 case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
33168 type = 0; ref_nested().clear();
33170 template<typename V> static inline void enumerate(V& v)
33172 v.template operator()<GlobalENB_ID>(1);
33173 v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
33177 template<typename V> bool decode(size_t index, V& v)
33182 case 1: v(select_id_GlobalENB_ID()); return true;
33183 case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
33184 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33189 template<typename V> bool encode(size_t index, V& v) const
33191 if(index != type) return false;
33194 case 1: v(var.as<GlobalENB_ID>()); return true;
33195 case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
33201 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33202 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33205 char dummy1[sizeof(GlobalENB_ID)];
33206 char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
33209 asn::variant<sizeof(union_type)> var;
33213 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33215 size_t get_index() const {return type;}
33216 bool is_unknown() const { return type == 3; }
33217 void clear() {type = 0;}
33218 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33219 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
33220 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33221 template<typename V> bool decode(V& v)
33224 if(!v(ref_nested())) return false;
33225 if(equal(mandatory)) { type = 1; return true; }
33226 else if(equal(mandatory)) { type = 2; return true; }
33227 else { type = 3; return true;}
33231 template<typename V> bool encode(V& v) const
33233 return v(ref_nested());
33237 template<typename V> bool decode(size_t index, V& v)
33242 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33243 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33244 case 3: type = 3; return v(ref_nested());
33245 ref_nested().clear();
33250 template<typename V> bool encode(size_t index, V& v) const
33252 if(index != type) {return false;} return v(ref_nested());
33262 ENB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
33263 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
33264 { ID id-ServedEUTRAcellsENDCX2ManagementList CRITICALITY reject TYPE ServedEUTRAcellsENDCX2ManagementList PRESENCE mandatory},
33269 struct ENB_ENDCX2SetupReqIEs
33271 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33273 size_t get_index() const {return type;}
33274 bool is_unknown() const { return type == 3; }
33275 void clear() {type = 0;}
33276 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
33277 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
33278 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33279 template<typename V> bool decode(V& v)
33282 if(!v(ref_nested())) return false;
33283 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
33284 else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
33285 else { type = 3; return true;}
33289 template<typename V> bool encode(V& v) const
33291 return v(ref_nested());
33295 template<typename V> bool decode(size_t index, V& v)
33300 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
33301 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
33302 case 3: type = 3; return v(ref_nested());
33303 ref_nested().clear();
33308 template<typename V> bool encode(size_t index, V& v) const
33310 if(index != type) {return false;} return v(ref_nested());
33317 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33319 size_t get_index() const {return type;}
33320 bool is_unknown() const { return type == 3; }
33321 void clear() {type = 0;}
33322 void select_id_GlobalENB_ID() { set(reject); type=1;}
33323 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
33324 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33325 template<typename V> bool decode(V& v)
33328 if(!v(ref_nested())) return false;
33329 if(equal(reject)) { type = 1; return true; }
33330 else if(equal(reject)) { type = 2; return true; }
33331 else { type = 3; return true;}
33335 template<typename V> bool encode(V& v) const
33337 return v(ref_nested());
33341 template<typename V> bool decode(size_t index, V& v)
33346 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33347 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33348 case 3: type = 3; return v(ref_nested());
33349 ref_nested().clear();
33354 template<typename V> bool encode(size_t index, V& v) const
33356 if(index != type) {return false;} return v(ref_nested());
33363 struct Value_t : asn::typefield<true>
33365 ~Value_t() {clear();}
33366 size_t get_index() const {return type;}
33367 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
33368 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
33369 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
33370 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
33371 bool is_unknown() const { return type == 3; }
33376 case 1: var.destroy<GlobalENB_ID>(); break;
33377 case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
33379 type = 0; ref_nested().clear();
33381 template<typename V> static inline void enumerate(V& v)
33383 v.template operator()<GlobalENB_ID>(1);
33384 v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
33388 template<typename V> bool decode(size_t index, V& v)
33393 case 1: v(select_id_GlobalENB_ID()); return true;
33394 case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
33395 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33400 template<typename V> bool encode(size_t index, V& v) const
33402 if(index != type) return false;
33405 case 1: v(var.as<GlobalENB_ID>()); return true;
33406 case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
33412 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33413 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33416 char dummy1[sizeof(GlobalENB_ID)];
33417 char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
33420 asn::variant<sizeof(union_type)> var;
33424 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33426 size_t get_index() const {return type;}
33427 bool is_unknown() const { return type == 3; }
33428 void clear() {type = 0;}
33429 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33430 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
33431 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33432 template<typename V> bool decode(V& v)
33435 if(!v(ref_nested())) return false;
33436 if(equal(mandatory)) { type = 1; return true; }
33437 else if(equal(mandatory)) { type = 2; return true; }
33438 else { type = 3; return true;}
33442 template<typename V> bool encode(V& v) const
33444 return v(ref_nested());
33448 template<typename V> bool decode(size_t index, V& v)
33453 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33454 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33455 case 3: type = 3; return v(ref_nested());
33456 ref_nested().clear();
33461 template<typename V> bool encode(size_t index, V& v) const
33463 if(index != type) {return false;} return v(ref_nested());
33473 ListofEUTRACellsinEUTRACoordinationResp ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
33476 struct ListofEUTRACellsinEUTRACoordinationResp_elm : ECGI
33478 static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp_elm";}
33479 using parent_t = ECGI;
33482 struct ListofEUTRACellsinEUTRACoordinationResp : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>
33484 static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp";}
33485 using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>;
33486 using constraint_t = asn::constraints<false,asn::span<0, maxCellineNB >>;
33490 ENB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
33491 { ID id-DataTrafficResourceIndication CRITICALITY reject TYPE DataTrafficResourceIndication PRESENCE mandatory}|
33492 { ID id-SpectrumSharingGroupID CRITICALITY reject TYPE SpectrumSharingGroupID PRESENCE mandatory}|
33493 { ID id-ListofEUTRACellsinEUTRACoordinationResp CRITICALITY reject TYPE ListofEUTRACellsinEUTRACoordinationResp PRESENCE mandatory},
33498 struct ENB_EUTRA_NRCellResourceCoordinationReqAckIEs
33500 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33502 size_t get_index() const {return type;}
33503 bool is_unknown() const { return type == 4; }
33504 void clear() {type = 0;}
33505 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
33506 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
33507 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(id_ListofEUTRACellsinEUTRACoordinationResp); type=3;}
33508 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33509 template<typename V> bool decode(V& v)
33512 if(!v(ref_nested())) return false;
33513 if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
33514 else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
33515 else if(equal(id_ListofEUTRACellsinEUTRACoordinationResp)) { type = 3; return true; }
33516 else { type = 4; return true;}
33520 template<typename V> bool encode(V& v) const
33522 return v(ref_nested());
33526 template<typename V> bool decode(size_t index, V& v)
33531 case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
33532 case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
33533 case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationResp);} return false;
33534 case 4: type = 4; return v(ref_nested());
33535 ref_nested().clear();
33540 template<typename V> bool encode(size_t index, V& v) const
33542 if(index != type) {return false;} return v(ref_nested());
33549 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33551 size_t get_index() const {return type;}
33552 bool is_unknown() const { return type == 4; }
33553 void clear() {type = 0;}
33554 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
33555 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
33556 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(reject); type=3;}
33557 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33558 template<typename V> bool decode(V& v)
33561 if(!v(ref_nested())) return false;
33562 if(equal(reject)) { type = 1; return true; }
33563 else if(equal(reject)) { type = 2; return true; }
33564 else if(equal(reject)) { type = 3; return true; }
33565 else { type = 4; return true;}
33569 template<typename V> bool encode(V& v) const
33571 return v(ref_nested());
33575 template<typename V> bool decode(size_t index, V& v)
33580 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33581 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33582 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
33583 case 4: type = 4; return v(ref_nested());
33584 ref_nested().clear();
33589 template<typename V> bool encode(size_t index, V& v) const
33591 if(index != type) {return false;} return v(ref_nested());
33598 struct Value_t : asn::typefield<true>
33600 ~Value_t() {clear();}
33601 size_t get_index() const {return type;}
33602 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
33603 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
33604 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
33605 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
33606 ListofEUTRACellsinEUTRACoordinationResp& select_id_ListofEUTRACellsinEUTRACoordinationResp() { return set<ListofEUTRACellsinEUTRACoordinationResp>(3); }
33607 ListofEUTRACellsinEUTRACoordinationResp const* get_id_ListofEUTRACellsinEUTRACoordinationResp() const { return get<ListofEUTRACellsinEUTRACoordinationResp>(3); }
33608 bool is_unknown() const { return type == 4; }
33613 case 1: var.destroy<DataTrafficResourceIndication>(); break;
33614 case 2: var.destroy<SpectrumSharingGroupID>(); break;
33615 case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationResp>(); break;
33617 type = 0; ref_nested().clear();
33619 template<typename V> static inline void enumerate(V& v)
33621 v.template operator()<DataTrafficResourceIndication>(1);
33622 v.template operator()<SpectrumSharingGroupID>(2);
33623 v.template operator()<ListofEUTRACellsinEUTRACoordinationResp>(3);
33627 template<typename V> bool decode(size_t index, V& v)
33632 case 1: v(select_id_DataTrafficResourceIndication()); return true;
33633 case 2: v(select_id_SpectrumSharingGroupID()); return true;
33634 case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationResp()); return true;
33635 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
33640 template<typename V> bool encode(size_t index, V& v) const
33642 if(index != type) return false;
33645 case 1: v(var.as<DataTrafficResourceIndication>()); return true;
33646 case 2: v(var.as<SpectrumSharingGroupID>()); return true;
33647 case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationResp>()); return true;
33653 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33654 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33657 char dummy1[sizeof(DataTrafficResourceIndication)];
33658 char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationResp)];
33659 char dummy3[sizeof(SpectrumSharingGroupID)];
33662 asn::variant<sizeof(union_type)> var;
33666 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33668 size_t get_index() const {return type;}
33669 bool is_unknown() const { return type == 4; }
33670 void clear() {type = 0;}
33671 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
33672 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
33673 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(mandatory); type=3;}
33674 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33675 template<typename V> bool decode(V& v)
33678 if(!v(ref_nested())) return false;
33679 if(equal(mandatory)) { type = 1; return true; }
33680 else if(equal(mandatory)) { type = 2; return true; }
33681 else if(equal(mandatory)) { type = 3; return true; }
33682 else { type = 4; return true;}
33686 template<typename V> bool encode(V& v) const
33688 return v(ref_nested());
33692 template<typename V> bool decode(size_t index, V& v)
33697 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33698 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33699 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
33700 case 4: type = 4; return v(ref_nested());
33701 ref_nested().clear();
33706 template<typename V> bool encode(size_t index, V& v) const
33708 if(index != type) {return false;} return v(ref_nested());
33718 ListofEUTRACellsinEUTRACoordinationReq ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
33721 struct ListofEUTRACellsinEUTRACoordinationReq_elm : ECGI
33723 static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq_elm";}
33724 using parent_t = ECGI;
33727 struct ListofEUTRACellsinEUTRACoordinationReq : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>
33729 static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq";}
33730 using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>;
33731 using constraint_t = asn::constraints<false,asn::span<0, maxCellineNB >>;
33735 ENB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
33736 { ID id-DataTrafficResourceIndication CRITICALITY reject TYPE DataTrafficResourceIndication PRESENCE mandatory}|
33737 { ID id-SpectrumSharingGroupID CRITICALITY reject TYPE SpectrumSharingGroupID PRESENCE mandatory}|
33738 { ID id-ListofEUTRACellsinEUTRACoordinationReq CRITICALITY reject TYPE ListofEUTRACellsinEUTRACoordinationReq PRESENCE mandatory},
33743 struct ENB_EUTRA_NRCellResourceCoordinationReqIEs
33745 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33747 size_t get_index() const {return type;}
33748 bool is_unknown() const { return type == 4; }
33749 void clear() {type = 0;}
33750 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
33751 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
33752 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(id_ListofEUTRACellsinEUTRACoordinationReq); type=3;}
33753 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33754 template<typename V> bool decode(V& v)
33757 if(!v(ref_nested())) return false;
33758 if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
33759 else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
33760 else if(equal(id_ListofEUTRACellsinEUTRACoordinationReq)) { type = 3; return true; }
33761 else { type = 4; return true;}
33765 template<typename V> bool encode(V& v) const
33767 return v(ref_nested());
33771 template<typename V> bool decode(size_t index, V& v)
33776 case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
33777 case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
33778 case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationReq);} return false;
33779 case 4: type = 4; return v(ref_nested());
33780 ref_nested().clear();
33785 template<typename V> bool encode(size_t index, V& v) const
33787 if(index != type) {return false;} return v(ref_nested());
33794 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33796 size_t get_index() const {return type;}
33797 bool is_unknown() const { return type == 4; }
33798 void clear() {type = 0;}
33799 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
33800 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
33801 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(reject); type=3;}
33802 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33803 template<typename V> bool decode(V& v)
33806 if(!v(ref_nested())) return false;
33807 if(equal(reject)) { type = 1; return true; }
33808 else if(equal(reject)) { type = 2; return true; }
33809 else if(equal(reject)) { type = 3; return true; }
33810 else { type = 4; return true;}
33814 template<typename V> bool encode(V& v) const
33816 return v(ref_nested());
33820 template<typename V> bool decode(size_t index, V& v)
33825 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33826 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33827 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
33828 case 4: type = 4; return v(ref_nested());
33829 ref_nested().clear();
33834 template<typename V> bool encode(size_t index, V& v) const
33836 if(index != type) {return false;} return v(ref_nested());
33843 struct Value_t : asn::typefield<true>
33845 ~Value_t() {clear();}
33846 size_t get_index() const {return type;}
33847 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
33848 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
33849 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
33850 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
33851 ListofEUTRACellsinEUTRACoordinationReq& select_id_ListofEUTRACellsinEUTRACoordinationReq() { return set<ListofEUTRACellsinEUTRACoordinationReq>(3); }
33852 ListofEUTRACellsinEUTRACoordinationReq const* get_id_ListofEUTRACellsinEUTRACoordinationReq() const { return get<ListofEUTRACellsinEUTRACoordinationReq>(3); }
33853 bool is_unknown() const { return type == 4; }
33858 case 1: var.destroy<DataTrafficResourceIndication>(); break;
33859 case 2: var.destroy<SpectrumSharingGroupID>(); break;
33860 case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationReq>(); break;
33862 type = 0; ref_nested().clear();
33864 template<typename V> static inline void enumerate(V& v)
33866 v.template operator()<DataTrafficResourceIndication>(1);
33867 v.template operator()<SpectrumSharingGroupID>(2);
33868 v.template operator()<ListofEUTRACellsinEUTRACoordinationReq>(3);
33872 template<typename V> bool decode(size_t index, V& v)
33877 case 1: v(select_id_DataTrafficResourceIndication()); return true;
33878 case 2: v(select_id_SpectrumSharingGroupID()); return true;
33879 case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationReq()); return true;
33880 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
33885 template<typename V> bool encode(size_t index, V& v) const
33887 if(index != type) return false;
33890 case 1: v(var.as<DataTrafficResourceIndication>()); return true;
33891 case 2: v(var.as<SpectrumSharingGroupID>()); return true;
33892 case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationReq>()); return true;
33898 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33899 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33902 char dummy1[sizeof(DataTrafficResourceIndication)];
33903 char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationReq)];
33904 char dummy3[sizeof(SpectrumSharingGroupID)];
33907 asn::variant<sizeof(union_type)> var;
33911 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33913 size_t get_index() const {return type;}
33914 bool is_unknown() const { return type == 4; }
33915 void clear() {type = 0;}
33916 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
33917 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
33918 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(mandatory); type=3;}
33919 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33920 template<typename V> bool decode(V& v)
33923 if(!v(ref_nested())) return false;
33924 if(equal(mandatory)) { type = 1; return true; }
33925 else if(equal(mandatory)) { type = 2; return true; }
33926 else if(equal(mandatory)) { type = 3; return true; }
33927 else { type = 4; return true;}
33931 template<typename V> bool encode(V& v) const
33933 return v(ref_nested());
33937 template<typename V> bool decode(size_t index, V& v)
33942 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33943 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33944 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
33945 case 4: type = 4; return v(ref_nested());
33946 ref_nested().clear();
33951 template<typename V> bool encode(size_t index, V& v) const
33953 if(index != type) {return false;} return v(ref_nested());
33963 ServedCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33964 { ID id-DeactivationIndication CRITICALITY ignore EXTENSION DeactivationIndication PRESENCE optional },
33969 struct ServedCellsToModify_Item_ExtIEs
33971 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33973 size_t get_index() const {return type;}
33974 bool is_unknown() const { return type == 2; }
33975 void clear() {type = 0;}
33976 void select_id_DeactivationIndication() { set(id_DeactivationIndication); type=1;}
33977 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33978 template<typename V> bool decode(V& v)
33981 if(!v(ref_nested())) return false;
33982 if(equal(id_DeactivationIndication)) { type = 1; return true; }
33983 else { type = 2; return true;}
33987 template<typename V> bool encode(V& v) const
33989 return v(ref_nested());
33993 template<typename V> bool decode(size_t index, V& v)
33998 case 1: type = 1; if(v(ref_nested())) { return equal(id_DeactivationIndication);} return false;
33999 case 2: type = 2; return v(ref_nested());
34000 ref_nested().clear();
34005 template<typename V> bool encode(size_t index, V& v) const
34007 if(index != type) {return false;} return v(ref_nested());
34014 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34016 size_t get_index() const {return type;}
34017 bool is_unknown() const { return type == 2; }
34018 void clear() {type = 0;}
34019 void select_id_DeactivationIndication() { set(ignore); type=1;}
34020 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34021 template<typename V> bool decode(V& v)
34024 if(!v(ref_nested())) return false;
34025 if(equal(ignore)) { type = 1; return true; }
34026 else { type = 2; return true;}
34030 template<typename V> bool encode(V& v) const
34032 return v(ref_nested());
34036 template<typename V> bool decode(size_t index, V& v)
34041 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34042 case 2: type = 2; return v(ref_nested());
34043 ref_nested().clear();
34048 template<typename V> bool encode(size_t index, V& v) const
34050 if(index != type) {return false;} return v(ref_nested());
34057 struct Extension_t : asn::typefield<true>
34059 ~Extension_t() {clear();}
34060 size_t get_index() const {return type;}
34061 DeactivationIndication& select_id_DeactivationIndication() { return set<DeactivationIndication>(1); }
34062 DeactivationIndication const* get_id_DeactivationIndication() const { return get<DeactivationIndication>(1); }
34063 bool is_unknown() const { return type == 2; }
34068 case 1: var.destroy<DeactivationIndication>(); break;
34070 type = 0; ref_nested().clear();
34072 template<typename V> static inline void enumerate(V& v)
34074 v.template operator()<DeactivationIndication>(1);
34078 template<typename V> bool decode(size_t index, V& v)
34083 case 1: v(select_id_DeactivationIndication()); return true;
34084 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
34089 template<typename V> bool encode(size_t index, V& v) const
34091 if(index != type) return false;
34094 case 1: v(var.as<DeactivationIndication>()); return true;
34100 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34101 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34104 char dummy1[sizeof(DeactivationIndication)];
34107 asn::variant<sizeof(union_type)> var;
34111 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34113 size_t get_index() const {return type;}
34114 bool is_unknown() const { return type == 2; }
34115 void clear() {type = 0;}
34116 void select_id_DeactivationIndication() { set(optional); type=1;}
34117 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34118 template<typename V> bool decode(V& v)
34121 if(!v(ref_nested())) return false;
34122 if(equal(optional)) { type = 1; return true; }
34123 else { type = 2; return true;}
34127 template<typename V> bool encode(V& v) const
34129 return v(ref_nested());
34133 template<typename V> bool decode(size_t index, V& v)
34138 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34139 case 2: type = 2; return v(ref_nested());
34140 ref_nested().clear();
34145 template<typename V> bool encode(size_t index, V& v) const
34147 if(index != type) {return false;} return v(ref_nested());
34157 ServedCellsToModify-Item::= SEQUENCE {
34159 servedCellInfo ServedCell-Information,
34160 neighbour-Info Neighbour-Information OPTIONAL,
34161 iE-Extensions ProtocolExtensionContainer { {ServedCellsToModify-Item-ExtIEs} } OPTIONAL,
34166 struct ServedCellsToModify_Item : asn::sequence<4, 0, true, 2>
34168 static constexpr const char* name() {return "ServedCellsToModify-Item";}
34169 using parent_t = asn::sequence<4, 0, true, 2>;
34170 struct old_ecgi_t : ECGI
34172 static constexpr const char* name() {return "old_ecgi_t";}
34173 using parent_t = ECGI;
34176 old_ecgi_t& ref_old_ecgi() {return old_ecgi;}
34177 old_ecgi_t const& ref_old_ecgi() const {return old_ecgi;}
34178 struct servedCellInfo_t : ServedCell_Information
34180 static constexpr const char* name() {return "servedCellInfo_t";}
34181 using parent_t = ServedCell_Information;
34184 servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
34185 servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
34186 struct neighbour_Info_t : Neighbour_Information
34188 static constexpr const char* name() {return "neighbour_Info_t";}
34189 using parent_t = Neighbour_Information;
34190 static constexpr bool optional = true;
34193 neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
34194 neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
34195 struct iE_Extensions_t : ProtocolExtensionContainer<ServedCellsToModify_Item_ExtIEs>
34197 static constexpr const char* name() {return "iE_Extensions_t";}
34198 using parent_t = ProtocolExtensionContainer<ServedCellsToModify_Item_ExtIEs>;
34199 static constexpr bool optional = true;
34202 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34203 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34204 template<typename V> void decode(V& v)
34212 template<typename V> void encode(V& v) const
34223 servedCellInfo.clear();
34224 neighbour_Info.clear();
34225 iE_Extensions.clear();
34229 old_ecgi_t old_ecgi;
34230 servedCellInfo_t servedCellInfo;
34231 neighbour_Info_t neighbour_Info;
34232 iE_Extensions_t iE_Extensions;
34236 ServedCellsToModify::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToModify-Item
34239 struct ServedCellsToModify_elm : ServedCellsToModify_Item
34241 static constexpr const char* name() {return "ServedCellsToModify_elm";}
34242 using parent_t = ServedCellsToModify_Item;
34245 struct ServedCellsToModify : asn::sequenceof<ServedCellsToModify_elm>
34247 static constexpr const char* name() {return "ServedCellsToModify";}
34248 using parent_t = asn::sequenceof<ServedCellsToModify_elm>;
34249 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
34253 Old-ECGIs::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
34256 struct Old_ECGIs_elm : ECGI
34258 static constexpr const char* name() {return "Old_ECGIs_elm";}
34259 using parent_t = ECGI;
34262 struct Old_ECGIs : asn::sequenceof<Old_ECGIs_elm>
34264 static constexpr const char* name() {return "Old-ECGIs";}
34265 using parent_t = asn::sequenceof<Old_ECGIs_elm>;
34266 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
34270 ENBConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
34271 { ID id-ServedCellsToAdd CRITICALITY reject TYPE ServedCells PRESENCE optional}|
34272 { ID id-ServedCellsToModify CRITICALITY reject TYPE ServedCellsToModify PRESENCE optional}|
34273 { ID id-ServedCellsToDelete CRITICALITY reject TYPE Old-ECGIs PRESENCE optional}|
34274 { ID id-GUGroupIDToAddList CRITICALITY reject TYPE GUGroupIDList PRESENCE optional}|
34275 { ID id-GUGroupIDToDeleteList CRITICALITY reject TYPE GUGroupIDList PRESENCE optional}|
34276 { ID id-CoverageModificationList CRITICALITY reject TYPE CoverageModificationList PRESENCE optional},
34281 struct ENBConfigurationUpdate_IEs
34283 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34285 size_t get_index() const {return type;}
34286 bool is_unknown() const { return type == 7; }
34287 void clear() {type = 0;}
34288 void select_id_ServedCellsToAdd() { set(id_ServedCellsToAdd); type=1;}
34289 void select_id_ServedCellsToModify() { set(id_ServedCellsToModify); type=2;}
34290 void select_id_ServedCellsToDelete() { set(id_ServedCellsToDelete); type=3;}
34291 void select_id_GUGroupIDToAddList() { set(id_GUGroupIDToAddList); type=4;}
34292 void select_id_GUGroupIDToDeleteList() { set(id_GUGroupIDToDeleteList); type=5;}
34293 void select_id_CoverageModificationList() { set(id_CoverageModificationList); type=6;}
34294 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34295 template<typename V> bool decode(V& v)
34298 if(!v(ref_nested())) return false;
34299 if(equal(id_ServedCellsToAdd)) { type = 1; return true; }
34300 else if(equal(id_ServedCellsToModify)) { type = 2; return true; }
34301 else if(equal(id_ServedCellsToDelete)) { type = 3; return true; }
34302 else if(equal(id_GUGroupIDToAddList)) { type = 4; return true; }
34303 else if(equal(id_GUGroupIDToDeleteList)) { type = 5; return true; }
34304 else if(equal(id_CoverageModificationList)) { type = 6; return true; }
34305 else { type = 7; return true;}
34309 template<typename V> bool encode(V& v) const
34311 return v(ref_nested());
34315 template<typename V> bool decode(size_t index, V& v)
34320 case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedCellsToAdd);} return false;
34321 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCellsToModify);} return false;
34322 case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedCellsToDelete);} return false;
34323 case 4: type = 4; if(v(ref_nested())) { return equal(id_GUGroupIDToAddList);} return false;
34324 case 5: type = 5; if(v(ref_nested())) { return equal(id_GUGroupIDToDeleteList);} return false;
34325 case 6: type = 6; if(v(ref_nested())) { return equal(id_CoverageModificationList);} return false;
34326 case 7: type = 7; return v(ref_nested());
34327 ref_nested().clear();
34332 template<typename V> bool encode(size_t index, V& v) const
34334 if(index != type) {return false;} return v(ref_nested());
34341 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34343 size_t get_index() const {return type;}
34344 bool is_unknown() const { return type == 7; }
34345 void clear() {type = 0;}
34346 void select_id_ServedCellsToAdd() { set(reject); type=1;}
34347 void select_id_ServedCellsToModify() { set(reject); type=2;}
34348 void select_id_ServedCellsToDelete() { set(reject); type=3;}
34349 void select_id_GUGroupIDToAddList() { set(reject); type=4;}
34350 void select_id_GUGroupIDToDeleteList() { set(reject); type=5;}
34351 void select_id_CoverageModificationList() { set(reject); type=6;}
34352 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34353 template<typename V> bool decode(V& v)
34356 if(!v(ref_nested())) return false;
34357 if(equal(reject)) { type = 1; return true; }
34358 else if(equal(reject)) { type = 2; return true; }
34359 else if(equal(reject)) { type = 3; return true; }
34360 else if(equal(reject)) { type = 4; return true; }
34361 else if(equal(reject)) { type = 5; return true; }
34362 else if(equal(reject)) { type = 6; return true; }
34363 else { type = 7; return true;}
34367 template<typename V> bool encode(V& v) const
34369 return v(ref_nested());
34373 template<typename V> bool decode(size_t index, V& v)
34378 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
34379 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
34380 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
34381 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
34382 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
34383 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
34384 case 7: type = 7; return v(ref_nested());
34385 ref_nested().clear();
34390 template<typename V> bool encode(size_t index, V& v) const
34392 if(index != type) {return false;} return v(ref_nested());
34399 struct Value_t : asn::typefield<true>
34401 ~Value_t() {clear();}
34402 size_t get_index() const {return type;}
34403 ServedCells& select_id_ServedCellsToAdd() { return set<ServedCells>(1); }
34404 ServedCells const* get_id_ServedCellsToAdd() const { return get<ServedCells>(1); }
34405 ServedCellsToModify& select_id_ServedCellsToModify() { return set<ServedCellsToModify>(2); }
34406 ServedCellsToModify const* get_id_ServedCellsToModify() const { return get<ServedCellsToModify>(2); }
34407 Old_ECGIs& select_id_ServedCellsToDelete() { return set<Old_ECGIs>(3); }
34408 Old_ECGIs const* get_id_ServedCellsToDelete() const { return get<Old_ECGIs>(3); }
34409 GUGroupIDList& select_id_GUGroupIDToAddList() { return set<GUGroupIDList>(4); }
34410 GUGroupIDList const* get_id_GUGroupIDToAddList() const { return get<GUGroupIDList>(4); }
34411 GUGroupIDList& select_id_GUGroupIDToDeleteList() { return set<GUGroupIDList>(5); }
34412 GUGroupIDList const* get_id_GUGroupIDToDeleteList() const { return get<GUGroupIDList>(5); }
34413 CoverageModificationList& select_id_CoverageModificationList() { return set<CoverageModificationList>(6); }
34414 CoverageModificationList const* get_id_CoverageModificationList() const { return get<CoverageModificationList>(6); }
34415 bool is_unknown() const { return type == 7; }
34420 case 1: var.destroy<ServedCells>(); break;
34421 case 2: var.destroy<ServedCellsToModify>(); break;
34422 case 3: var.destroy<Old_ECGIs>(); break;
34423 case 4: var.destroy<GUGroupIDList>(); break;
34424 case 5: var.destroy<GUGroupIDList>(); break;
34425 case 6: var.destroy<CoverageModificationList>(); break;
34427 type = 0; ref_nested().clear();
34429 template<typename V> static inline void enumerate(V& v)
34431 v.template operator()<ServedCells>(1);
34432 v.template operator()<ServedCellsToModify>(2);
34433 v.template operator()<Old_ECGIs>(3);
34434 v.template operator()<GUGroupIDList>(4);
34435 v.template operator()<GUGroupIDList>(5);
34436 v.template operator()<CoverageModificationList>(6);
34440 template<typename V> bool decode(size_t index, V& v)
34445 case 1: v(select_id_ServedCellsToAdd()); return true;
34446 case 2: v(select_id_ServedCellsToModify()); return true;
34447 case 3: v(select_id_ServedCellsToDelete()); return true;
34448 case 4: v(select_id_GUGroupIDToAddList()); return true;
34449 case 5: v(select_id_GUGroupIDToDeleteList()); return true;
34450 case 6: v(select_id_CoverageModificationList()); return true;
34451 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
34456 template<typename V> bool encode(size_t index, V& v) const
34458 if(index != type) return false;
34461 case 1: v(var.as<ServedCells>()); return true;
34462 case 2: v(var.as<ServedCellsToModify>()); return true;
34463 case 3: v(var.as<Old_ECGIs>()); return true;
34464 case 4: v(var.as<GUGroupIDList>()); return true;
34465 case 5: v(var.as<GUGroupIDList>()); return true;
34466 case 6: v(var.as<CoverageModificationList>()); return true;
34472 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34473 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34476 char dummy1[sizeof(CoverageModificationList)];
34477 char dummy2[sizeof(GUGroupIDList)];
34478 char dummy3[sizeof(Old_ECGIs)];
34479 char dummy4[sizeof(ServedCells)];
34480 char dummy5[sizeof(ServedCellsToModify)];
34483 asn::variant<sizeof(union_type)> var;
34487 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34489 size_t get_index() const {return type;}
34490 bool is_unknown() const { return type == 7; }
34491 void clear() {type = 0;}
34492 void select_id_ServedCellsToAdd() { set(optional); type=1;}
34493 void select_id_ServedCellsToModify() { set(optional); type=2;}
34494 void select_id_ServedCellsToDelete() { set(optional); type=3;}
34495 void select_id_GUGroupIDToAddList() { set(optional); type=4;}
34496 void select_id_GUGroupIDToDeleteList() { set(optional); type=5;}
34497 void select_id_CoverageModificationList() { set(optional); type=6;}
34498 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
34499 template<typename V> bool decode(V& v)
34502 if(!v(ref_nested())) return false;
34503 if(equal(optional)) { type = 1; return true; }
34504 else if(equal(optional)) { type = 2; return true; }
34505 else if(equal(optional)) { type = 3; return true; }
34506 else if(equal(optional)) { type = 4; return true; }
34507 else if(equal(optional)) { type = 5; return true; }
34508 else if(equal(optional)) { type = 6; return true; }
34509 else { type = 7; return true;}
34513 template<typename V> bool encode(V& v) const
34515 return v(ref_nested());
34519 template<typename V> bool decode(size_t index, V& v)
34524 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34525 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
34526 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
34527 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
34528 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
34529 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
34530 case 7: type = 7; return v(ref_nested());
34531 ref_nested().clear();
34536 template<typename V> bool encode(size_t index, V& v) const
34538 if(index != type) {return false;} return v(ref_nested());
34548 ENBConfigurationUpdate ::= SEQUENCE {
34549 protocolIEs ProtocolIE-Container {{ENBConfigurationUpdate-IEs}},
34554 struct ENBConfigurationUpdate : asn::sequence<1, 0, true, 0>
34556 static constexpr const char* name() {return "ENBConfigurationUpdate";}
34557 using parent_t = asn::sequence<1, 0, true, 0>;
34558 struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdate_IEs>
34560 static constexpr const char* name() {return "protocolIEs_t";}
34561 using parent_t = ProtocolIE_Container<ENBConfigurationUpdate_IEs>;
34564 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
34565 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
34566 template<typename V> void decode(V& v)
34571 template<typename V> void encode(V& v) const
34578 protocolIEs.clear();
34582 protocolIEs_t protocolIEs;
34586 ENBConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
34587 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
34592 struct ENBConfigurationUpdateAcknowledge_IEs
34594 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34596 size_t get_index() const {return type;}
34597 bool is_unknown() const { return type == 2; }
34598 void clear() {type = 0;}
34599 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=1;}
34600 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34601 template<typename V> bool decode(V& v)
34604 if(!v(ref_nested())) return false;
34605 if(equal(id_CriticalityDiagnostics)) { type = 1; return true; }
34606 else { type = 2; return true;}
34610 template<typename V> bool encode(V& v) const
34612 return v(ref_nested());
34616 template<typename V> bool decode(size_t index, V& v)
34621 case 1: type = 1; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
34622 case 2: type = 2; return v(ref_nested());
34623 ref_nested().clear();
34628 template<typename V> bool encode(size_t index, V& v) const
34630 if(index != type) {return false;} return v(ref_nested());
34637 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34639 size_t get_index() const {return type;}
34640 bool is_unknown() const { return type == 2; }
34641 void clear() {type = 0;}
34642 void select_id_CriticalityDiagnostics() { set(ignore); type=1;}
34643 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34644 template<typename V> bool decode(V& v)
34647 if(!v(ref_nested())) return false;
34648 if(equal(ignore)) { type = 1; return true; }
34649 else { type = 2; return true;}
34653 template<typename V> bool encode(V& v) const
34655 return v(ref_nested());
34659 template<typename V> bool decode(size_t index, V& v)
34664 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34665 case 2: type = 2; return v(ref_nested());
34666 ref_nested().clear();
34671 template<typename V> bool encode(size_t index, V& v) const
34673 if(index != type) {return false;} return v(ref_nested());
34680 struct Value_t : asn::typefield<true>
34682 ~Value_t() {clear();}
34683 size_t get_index() const {return type;}
34684 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
34685 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
34686 bool is_unknown() const { return type == 2; }
34691 case 1: var.destroy<CriticalityDiagnostics>(); break;
34693 type = 0; ref_nested().clear();
34695 template<typename V> static inline void enumerate(V& v)
34697 v.template operator()<CriticalityDiagnostics>(1);
34701 template<typename V> bool decode(size_t index, V& v)
34706 case 1: v(select_id_CriticalityDiagnostics()); return true;
34707 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
34712 template<typename V> bool encode(size_t index, V& v) const
34714 if(index != type) return false;
34717 case 1: v(var.as<CriticalityDiagnostics>()); return true;
34723 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34724 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34727 char dummy1[sizeof(CriticalityDiagnostics)];
34730 asn::variant<sizeof(union_type)> var;
34734 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34736 size_t get_index() const {return type;}
34737 bool is_unknown() const { return type == 2; }
34738 void clear() {type = 0;}
34739 void select_id_CriticalityDiagnostics() { set(optional); type=1;}
34740 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
34741 template<typename V> bool decode(V& v)
34744 if(!v(ref_nested())) return false;
34745 if(equal(optional)) { type = 1; return true; }
34746 else { type = 2; return true;}
34750 template<typename V> bool encode(V& v) const
34752 return v(ref_nested());
34756 template<typename V> bool decode(size_t index, V& v)
34761 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34762 case 2: type = 2; return v(ref_nested());
34763 ref_nested().clear();
34768 template<typename V> bool encode(size_t index, V& v) const
34770 if(index != type) {return false;} return v(ref_nested());
34780 ENBConfigurationUpdateAcknowledge ::= SEQUENCE {
34781 protocolIEs ProtocolIE-Container {{ENBConfigurationUpdateAcknowledge-IEs}},
34786 struct ENBConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
34788 static constexpr const char* name() {return "ENBConfigurationUpdateAcknowledge";}
34789 using parent_t = asn::sequence<1, 0, true, 0>;
34790 struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>
34792 static constexpr const char* name() {return "protocolIEs_t";}
34793 using parent_t = ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>;
34796 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
34797 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
34798 template<typename V> void decode(V& v)
34803 template<typename V> void encode(V& v) const
34810 protocolIEs.clear();
34814 protocolIEs_t protocolIEs;
34818 ENBConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
34819 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
34820 { ID id-TimeToWait CRITICALITY ignore TYPE TimeToWait PRESENCE optional}|
34821 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
34826 struct ENBConfigurationUpdateFailure_IEs
34828 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34830 size_t get_index() const {return type;}
34831 bool is_unknown() const { return type == 4; }
34832 void clear() {type = 0;}
34833 void select_id_Cause() { set(id_Cause); type=1;}
34834 void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
34835 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
34836 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34837 template<typename V> bool decode(V& v)
34840 if(!v(ref_nested())) return false;
34841 if(equal(id_Cause)) { type = 1; return true; }
34842 else if(equal(id_TimeToWait)) { type = 2; return true; }
34843 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
34844 else { type = 4; return true;}
34848 template<typename V> bool encode(V& v) const
34850 return v(ref_nested());
34854 template<typename V> bool decode(size_t index, V& v)
34859 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
34860 case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
34861 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
34862 case 4: type = 4; return v(ref_nested());
34863 ref_nested().clear();
34868 template<typename V> bool encode(size_t index, V& v) const
34870 if(index != type) {return false;} return v(ref_nested());
34877 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34879 size_t get_index() const {return type;}
34880 bool is_unknown() const { return type == 4; }
34881 void clear() {type = 0;}
34882 void select_id_Cause() { set(ignore); type=1;}
34883 void select_id_TimeToWait() { set(ignore); type=2;}
34884 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
34885 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34886 template<typename V> bool decode(V& v)
34889 if(!v(ref_nested())) return false;
34890 if(equal(ignore)) { type = 1; return true; }
34891 else if(equal(ignore)) { type = 2; return true; }
34892 else if(equal(ignore)) { type = 3; return true; }
34893 else { type = 4; return true;}
34897 template<typename V> bool encode(V& v) const
34899 return v(ref_nested());
34903 template<typename V> bool decode(size_t index, V& v)
34908 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34909 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
34910 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
34911 case 4: type = 4; return v(ref_nested());
34912 ref_nested().clear();
34917 template<typename V> bool encode(size_t index, V& v) const
34919 if(index != type) {return false;} return v(ref_nested());
34926 struct Value_t : asn::typefield<true>
34928 ~Value_t() {clear();}
34929 size_t get_index() const {return type;}
34930 Cause& select_id_Cause() { return set<Cause>(1); }
34931 Cause const* get_id_Cause() const { return get<Cause>(1); }
34932 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
34933 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
34934 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
34935 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
34936 bool is_unknown() const { return type == 4; }
34941 case 1: var.destroy<Cause>(); break;
34942 case 2: var.destroy<TimeToWait>(); break;
34943 case 3: var.destroy<CriticalityDiagnostics>(); break;
34945 type = 0; ref_nested().clear();
34947 template<typename V> static inline void enumerate(V& v)
34949 v.template operator()<Cause>(1);
34950 v.template operator()<TimeToWait>(2);
34951 v.template operator()<CriticalityDiagnostics>(3);
34955 template<typename V> bool decode(size_t index, V& v)
34960 case 1: v(select_id_Cause()); return true;
34961 case 2: v(select_id_TimeToWait()); return true;
34962 case 3: v(select_id_CriticalityDiagnostics()); return true;
34963 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
34968 template<typename V> bool encode(size_t index, V& v) const
34970 if(index != type) return false;
34973 case 1: v(var.as<Cause>()); return true;
34974 case 2: v(var.as<TimeToWait>()); return true;
34975 case 3: v(var.as<CriticalityDiagnostics>()); return true;
34981 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34982 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34985 char dummy1[sizeof(Cause)];
34986 char dummy2[sizeof(CriticalityDiagnostics)];
34987 char dummy3[sizeof(TimeToWait)];
34990 asn::variant<sizeof(union_type)> var;
34994 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34996 size_t get_index() const {return type;}
34997 bool is_unknown() const { return type == 4; }
34998 void clear() {type = 0;}
34999 void select_id_Cause() { set(mandatory); type=1;}
35000 void select_id_TimeToWait() { set(optional); type=2;}
35001 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
35002 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35003 template<typename V> bool decode(V& v)
35006 if(!v(ref_nested())) return false;
35007 if(equal(mandatory)) { type = 1; return true; }
35008 else if(equal(optional)) { type = 2; return true; }
35009 else if(equal(optional)) { type = 3; return true; }
35010 else { type = 4; return true;}
35014 template<typename V> bool encode(V& v) const
35016 return v(ref_nested());
35020 template<typename V> bool decode(size_t index, V& v)
35025 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35026 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
35027 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
35028 case 4: type = 4; return v(ref_nested());
35029 ref_nested().clear();
35034 template<typename V> bool encode(size_t index, V& v) const
35036 if(index != type) {return false;} return v(ref_nested());
35046 ENBConfigurationUpdateFailure ::= SEQUENCE {
35047 protocolIEs ProtocolIE-Container {{ENBConfigurationUpdateFailure-IEs}},
35052 struct ENBConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
35054 static constexpr const char* name() {return "ENBConfigurationUpdateFailure";}
35055 using parent_t = asn::sequence<1, 0, true, 0>;
35056 struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>
35058 static constexpr const char* name() {return "protocolIEs_t";}
35059 using parent_t = ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>;
35062 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35063 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35064 template<typename V> void decode(V& v)
35069 template<typename V> void encode(V& v) const
35076 protocolIEs.clear();
35080 protocolIEs_t protocolIEs;
35084 ENDCCellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
35085 { ID id-ActivationID CRITICALITY reject TYPE ActivationID PRESENCE mandatory }|
35086 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory }|
35087 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional },
35092 struct ENDCCellActivationFailure_IEs
35094 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35096 size_t get_index() const {return type;}
35097 bool is_unknown() const { return type == 4; }
35098 void clear() {type = 0;}
35099 void select_id_ActivationID() { set(id_ActivationID); type=1;}
35100 void select_id_Cause() { set(id_Cause); type=2;}
35101 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
35102 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35103 template<typename V> bool decode(V& v)
35106 if(!v(ref_nested())) return false;
35107 if(equal(id_ActivationID)) { type = 1; return true; }
35108 else if(equal(id_Cause)) { type = 2; return true; }
35109 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
35110 else { type = 4; return true;}
35114 template<typename V> bool encode(V& v) const
35116 return v(ref_nested());
35120 template<typename V> bool decode(size_t index, V& v)
35125 case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35126 case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
35127 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
35128 case 4: type = 4; return v(ref_nested());
35129 ref_nested().clear();
35134 template<typename V> bool encode(size_t index, V& v) const
35136 if(index != type) {return false;} return v(ref_nested());
35143 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35145 size_t get_index() const {return type;}
35146 bool is_unknown() const { return type == 4; }
35147 void clear() {type = 0;}
35148 void select_id_ActivationID() { set(reject); type=1;}
35149 void select_id_Cause() { set(ignore); type=2;}
35150 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
35151 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35152 template<typename V> bool decode(V& v)
35155 if(!v(ref_nested())) return false;
35156 if(equal(reject)) { type = 1; return true; }
35157 else if(equal(ignore)) { type = 2; return true; }
35158 else if(equal(ignore)) { type = 3; return true; }
35159 else { type = 4; return true;}
35163 template<typename V> bool encode(V& v) const
35165 return v(ref_nested());
35169 template<typename V> bool decode(size_t index, V& v)
35174 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
35175 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
35176 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
35177 case 4: type = 4; return v(ref_nested());
35178 ref_nested().clear();
35183 template<typename V> bool encode(size_t index, V& v) const
35185 if(index != type) {return false;} return v(ref_nested());
35192 struct Value_t : asn::typefield<true>
35194 ~Value_t() {clear();}
35195 size_t get_index() const {return type;}
35196 ActivationID& select_id_ActivationID() { return set<ActivationID>(1); }
35197 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(1); }
35198 Cause& select_id_Cause() { return set<Cause>(2); }
35199 Cause const* get_id_Cause() const { return get<Cause>(2); }
35200 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
35201 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
35202 bool is_unknown() const { return type == 4; }
35207 case 1: var.destroy<ActivationID>(); break;
35208 case 2: var.destroy<Cause>(); break;
35209 case 3: var.destroy<CriticalityDiagnostics>(); break;
35211 type = 0; ref_nested().clear();
35213 template<typename V> static inline void enumerate(V& v)
35215 v.template operator()<ActivationID>(1);
35216 v.template operator()<Cause>(2);
35217 v.template operator()<CriticalityDiagnostics>(3);
35221 template<typename V> bool decode(size_t index, V& v)
35226 case 1: v(select_id_ActivationID()); return true;
35227 case 2: v(select_id_Cause()); return true;
35228 case 3: v(select_id_CriticalityDiagnostics()); return true;
35229 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
35234 template<typename V> bool encode(size_t index, V& v) const
35236 if(index != type) return false;
35239 case 1: v(var.as<ActivationID>()); return true;
35240 case 2: v(var.as<Cause>()); return true;
35241 case 3: v(var.as<CriticalityDiagnostics>()); return true;
35247 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35248 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35251 char dummy1[sizeof(ActivationID)];
35252 char dummy2[sizeof(Cause)];
35253 char dummy3[sizeof(CriticalityDiagnostics)];
35256 asn::variant<sizeof(union_type)> var;
35260 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
35262 size_t get_index() const {return type;}
35263 bool is_unknown() const { return type == 4; }
35264 void clear() {type = 0;}
35265 void select_id_ActivationID() { set(mandatory); type=1;}
35266 void select_id_Cause() { set(mandatory); type=2;}
35267 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
35268 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35269 template<typename V> bool decode(V& v)
35272 if(!v(ref_nested())) return false;
35273 if(equal(mandatory)) { type = 1; return true; }
35274 else if(equal(mandatory)) { type = 2; return true; }
35275 else if(equal(optional)) { type = 3; return true; }
35276 else { type = 4; return true;}
35280 template<typename V> bool encode(V& v) const
35282 return v(ref_nested());
35286 template<typename V> bool decode(size_t index, V& v)
35291 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35292 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
35293 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
35294 case 4: type = 4; return v(ref_nested());
35295 ref_nested().clear();
35300 template<typename V> bool encode(size_t index, V& v) const
35302 if(index != type) {return false;} return v(ref_nested());
35312 ENDCCellActivationFailure ::= SEQUENCE {
35313 protocolIEs ProtocolIE-Container {{ENDCCellActivationFailure-IEs}},
35318 struct ENDCCellActivationFailure : asn::sequence<1, 0, true, 0>
35320 static constexpr const char* name() {return "ENDCCellActivationFailure";}
35321 using parent_t = asn::sequence<1, 0, true, 0>;
35322 struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationFailure_IEs>
35324 static constexpr const char* name() {return "protocolIEs_t";}
35325 using parent_t = ProtocolIE_Container<ENDCCellActivationFailure_IEs>;
35328 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35329 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35330 template<typename V> void decode(V& v)
35335 template<typename V> void encode(V& v) const
35342 protocolIEs.clear();
35346 protocolIEs_t protocolIEs;
35350 ServedNRCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35355 struct ServedNRCellsToActivate_Item_ExtIEs
35357 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35359 size_t get_index() const {return type;}
35360 bool is_unknown() const { return type == 1; }
35361 void clear() {type = 0;}
35362 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35363 template<typename V> bool decode(V& v)
35366 if(!v(ref_nested())) return false;
35367 { type = 1; return true;}
35371 template<typename V> bool encode(V& v) const
35373 return v(ref_nested());
35377 template<typename V> bool decode(size_t index, V& v)
35382 case 1: type = 1; return v(ref_nested());
35383 ref_nested().clear();
35388 template<typename V> bool encode(size_t index, V& v) const
35390 if(index != type) {return false;} return v(ref_nested());
35397 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35399 size_t get_index() const {return type;}
35400 bool is_unknown() const { return type == 1; }
35401 void clear() {type = 0;}
35402 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35403 template<typename V> bool decode(V& v)
35406 if(!v(ref_nested())) return false;
35407 { type = 1; return true;}
35411 template<typename V> bool encode(V& v) const
35413 return v(ref_nested());
35417 template<typename V> bool decode(size_t index, V& v)
35422 case 1: type = 1; return v(ref_nested());
35423 ref_nested().clear();
35428 template<typename V> bool encode(size_t index, V& v) const
35430 if(index != type) {return false;} return v(ref_nested());
35437 struct Extension_t : asn::typefield<true>
35439 ~Extension_t() {clear();}
35440 size_t get_index() const {return type;}
35441 bool is_unknown() const { return type == 1; }
35444 type = 0; ref_nested().clear();
35446 template<typename V> static inline void enumerate(V& v)
35451 template<typename V> bool decode(size_t index, V& v)
35456 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35461 template<typename V> bool encode(size_t index, V& v) const
35463 if(index != type) return false;
35471 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35473 size_t get_index() const {return type;}
35474 bool is_unknown() const { return type == 1; }
35475 void clear() {type = 0;}
35476 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35477 template<typename V> bool decode(V& v)
35480 if(!v(ref_nested())) return false;
35481 { type = 1; return true;}
35485 template<typename V> bool encode(V& v) const
35487 return v(ref_nested());
35491 template<typename V> bool decode(size_t index, V& v)
35496 case 1: type = 1; return v(ref_nested());
35497 ref_nested().clear();
35502 template<typename V> bool encode(size_t index, V& v) const
35504 if(index != type) {return false;} return v(ref_nested());
35514 ServedNRCellsToActivate-Item::= SEQUENCE {
35516 iE-Extensions ProtocolExtensionContainer { {ServedNRCellsToActivate-Item-ExtIEs} } OPTIONAL,
35521 struct ServedNRCellsToActivate_Item : asn::sequence<2, 0, true, 1>
35523 static constexpr const char* name() {return "ServedNRCellsToActivate-Item";}
35524 using parent_t = asn::sequence<2, 0, true, 1>;
35525 struct nrCellID_t : NRCGI
35527 static constexpr const char* name() {return "nrCellID_t";}
35528 using parent_t = NRCGI;
35531 nrCellID_t& ref_nrCellID() {return nrCellID;}
35532 nrCellID_t const& ref_nrCellID() const {return nrCellID;}
35533 struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToActivate_Item_ExtIEs>
35535 static constexpr const char* name() {return "iE_Extensions_t";}
35536 using parent_t = ProtocolExtensionContainer<ServedNRCellsToActivate_Item_ExtIEs>;
35537 static constexpr bool optional = true;
35540 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35541 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35542 template<typename V> void decode(V& v)
35548 template<typename V> void encode(V& v) const
35557 iE_Extensions.clear();
35561 nrCellID_t nrCellID;
35562 iE_Extensions_t iE_Extensions;
35566 ServedNRCellsToActivate::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ServedNRCellsToActivate-Item
35569 struct ServedNRCellsToActivate_elm : ServedNRCellsToActivate_Item
35571 static constexpr const char* name() {return "ServedNRCellsToActivate_elm";}
35572 using parent_t = ServedNRCellsToActivate_Item;
35575 struct ServedNRCellsToActivate : asn::sequenceof<ServedNRCellsToActivate_elm>
35577 static constexpr const char* name() {return "ServedNRCellsToActivate";}
35578 using parent_t = asn::sequenceof<ServedNRCellsToActivate_elm>;
35579 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
35583 ENDCCellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
35584 { ID id-ServedNRCellsToActivate CRITICALITY reject TYPE ServedNRCellsToActivate PRESENCE mandatory}|
35585 { ID id-ActivationID CRITICALITY reject TYPE ActivationID PRESENCE mandatory},
35590 struct ENDCCellActivationRequest_IEs
35592 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35594 size_t get_index() const {return type;}
35595 bool is_unknown() const { return type == 3; }
35596 void clear() {type = 0;}
35597 void select_id_ServedNRCellsToActivate() { set(id_ServedNRCellsToActivate); type=1;}
35598 void select_id_ActivationID() { set(id_ActivationID); type=2;}
35599 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35600 template<typename V> bool decode(V& v)
35603 if(!v(ref_nested())) return false;
35604 if(equal(id_ServedNRCellsToActivate)) { type = 1; return true; }
35605 else if(equal(id_ActivationID)) { type = 2; return true; }
35606 else { type = 3; return true;}
35610 template<typename V> bool encode(V& v) const
35612 return v(ref_nested());
35616 template<typename V> bool decode(size_t index, V& v)
35621 case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRCellsToActivate);} return false;
35622 case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35623 case 3: type = 3; return v(ref_nested());
35624 ref_nested().clear();
35629 template<typename V> bool encode(size_t index, V& v) const
35631 if(index != type) {return false;} return v(ref_nested());
35638 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35640 size_t get_index() const {return type;}
35641 bool is_unknown() const { return type == 3; }
35642 void clear() {type = 0;}
35643 void select_id_ServedNRCellsToActivate() { set(reject); type=1;}
35644 void select_id_ActivationID() { set(reject); type=2;}
35645 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35646 template<typename V> bool decode(V& v)
35649 if(!v(ref_nested())) return false;
35650 if(equal(reject)) { type = 1; return true; }
35651 else if(equal(reject)) { type = 2; return true; }
35652 else { type = 3; return true;}
35656 template<typename V> bool encode(V& v) const
35658 return v(ref_nested());
35662 template<typename V> bool decode(size_t index, V& v)
35667 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
35668 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
35669 case 3: type = 3; return v(ref_nested());
35670 ref_nested().clear();
35675 template<typename V> bool encode(size_t index, V& v) const
35677 if(index != type) {return false;} return v(ref_nested());
35684 struct Value_t : asn::typefield<true>
35686 ~Value_t() {clear();}
35687 size_t get_index() const {return type;}
35688 ServedNRCellsToActivate& select_id_ServedNRCellsToActivate() { return set<ServedNRCellsToActivate>(1); }
35689 ServedNRCellsToActivate const* get_id_ServedNRCellsToActivate() const { return get<ServedNRCellsToActivate>(1); }
35690 ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
35691 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
35692 bool is_unknown() const { return type == 3; }
35697 case 1: var.destroy<ServedNRCellsToActivate>(); break;
35698 case 2: var.destroy<ActivationID>(); break;
35700 type = 0; ref_nested().clear();
35702 template<typename V> static inline void enumerate(V& v)
35704 v.template operator()<ServedNRCellsToActivate>(1);
35705 v.template operator()<ActivationID>(2);
35709 template<typename V> bool decode(size_t index, V& v)
35714 case 1: v(select_id_ServedNRCellsToActivate()); return true;
35715 case 2: v(select_id_ActivationID()); return true;
35716 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
35721 template<typename V> bool encode(size_t index, V& v) const
35723 if(index != type) return false;
35726 case 1: v(var.as<ServedNRCellsToActivate>()); return true;
35727 case 2: v(var.as<ActivationID>()); return true;
35733 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35734 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35737 char dummy1[sizeof(ActivationID)];
35738 char dummy2[sizeof(ServedNRCellsToActivate)];
35741 asn::variant<sizeof(union_type)> var;
35745 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
35747 size_t get_index() const {return type;}
35748 bool is_unknown() const { return type == 3; }
35749 void clear() {type = 0;}
35750 void select_id_ServedNRCellsToActivate() { set(mandatory); type=1;}
35751 void select_id_ActivationID() { set(mandatory); type=2;}
35752 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35753 template<typename V> bool decode(V& v)
35756 if(!v(ref_nested())) return false;
35757 if(equal(mandatory)) { type = 1; return true; }
35758 else if(equal(mandatory)) { type = 2; return true; }
35759 else { type = 3; return true;}
35763 template<typename V> bool encode(V& v) const
35765 return v(ref_nested());
35769 template<typename V> bool decode(size_t index, V& v)
35774 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35775 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
35776 case 3: type = 3; return v(ref_nested());
35777 ref_nested().clear();
35782 template<typename V> bool encode(size_t index, V& v) const
35784 if(index != type) {return false;} return v(ref_nested());
35794 ENDCCellActivationRequest ::= SEQUENCE {
35795 protocolIEs ProtocolIE-Container {{ENDCCellActivationRequest-IEs}},
35800 struct ENDCCellActivationRequest : asn::sequence<1, 0, true, 0>
35802 static constexpr const char* name() {return "ENDCCellActivationRequest";}
35803 using parent_t = asn::sequence<1, 0, true, 0>;
35804 struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationRequest_IEs>
35806 static constexpr const char* name() {return "protocolIEs_t";}
35807 using parent_t = ProtocolIE_Container<ENDCCellActivationRequest_IEs>;
35810 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35811 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35812 template<typename V> void decode(V& v)
35817 template<typename V> void encode(V& v) const
35824 protocolIEs.clear();
35828 protocolIEs_t protocolIEs;
35832 ENDCCellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
35833 { ID id-ActivatedNRCellList CRITICALITY ignore TYPE ActivatedNRCellList PRESENCE mandatory}|
35834 { ID id-ActivationID CRITICALITY reject TYPE ActivationID PRESENCE mandatory}|
35835 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
35840 struct ENDCCellActivationResponse_IEs
35842 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35844 size_t get_index() const {return type;}
35845 bool is_unknown() const { return type == 4; }
35846 void clear() {type = 0;}
35847 void select_id_ActivatedNRCellList() { set(id_ActivatedNRCellList); type=1;}
35848 void select_id_ActivationID() { set(id_ActivationID); type=2;}
35849 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
35850 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35851 template<typename V> bool decode(V& v)
35854 if(!v(ref_nested())) return false;
35855 if(equal(id_ActivatedNRCellList)) { type = 1; return true; }
35856 else if(equal(id_ActivationID)) { type = 2; return true; }
35857 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
35858 else { type = 4; return true;}
35862 template<typename V> bool encode(V& v) const
35864 return v(ref_nested());
35868 template<typename V> bool decode(size_t index, V& v)
35873 case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivatedNRCellList);} return false;
35874 case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35875 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
35876 case 4: type = 4; return v(ref_nested());
35877 ref_nested().clear();
35882 template<typename V> bool encode(size_t index, V& v) const
35884 if(index != type) {return false;} return v(ref_nested());
35891 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35893 size_t get_index() const {return type;}
35894 bool is_unknown() const { return type == 4; }
35895 void clear() {type = 0;}
35896 void select_id_ActivatedNRCellList() { set(ignore); type=1;}
35897 void select_id_ActivationID() { set(reject); type=2;}
35898 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
35899 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35900 template<typename V> bool decode(V& v)
35903 if(!v(ref_nested())) return false;
35904 if(equal(ignore)) { type = 1; return true; }
35905 else if(equal(reject)) { type = 2; return true; }
35906 else if(equal(ignore)) { type = 3; return true; }
35907 else { type = 4; return true;}
35911 template<typename V> bool encode(V& v) const
35913 return v(ref_nested());
35917 template<typename V> bool decode(size_t index, V& v)
35922 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
35923 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
35924 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
35925 case 4: type = 4; return v(ref_nested());
35926 ref_nested().clear();
35931 template<typename V> bool encode(size_t index, V& v) const
35933 if(index != type) {return false;} return v(ref_nested());
35940 struct Value_t : asn::typefield<true>
35942 ~Value_t() {clear();}
35943 size_t get_index() const {return type;}
35944 ActivatedNRCellList& select_id_ActivatedNRCellList() { return set<ActivatedNRCellList>(1); }
35945 ActivatedNRCellList const* get_id_ActivatedNRCellList() const { return get<ActivatedNRCellList>(1); }
35946 ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
35947 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
35948 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
35949 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
35950 bool is_unknown() const { return type == 4; }
35955 case 1: var.destroy<ActivatedNRCellList>(); break;
35956 case 2: var.destroy<ActivationID>(); break;
35957 case 3: var.destroy<CriticalityDiagnostics>(); break;
35959 type = 0; ref_nested().clear();
35961 template<typename V> static inline void enumerate(V& v)
35963 v.template operator()<ActivatedNRCellList>(1);
35964 v.template operator()<ActivationID>(2);
35965 v.template operator()<CriticalityDiagnostics>(3);
35969 template<typename V> bool decode(size_t index, V& v)
35974 case 1: v(select_id_ActivatedNRCellList()); return true;
35975 case 2: v(select_id_ActivationID()); return true;
35976 case 3: v(select_id_CriticalityDiagnostics()); return true;
35977 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
35982 template<typename V> bool encode(size_t index, V& v) const
35984 if(index != type) return false;
35987 case 1: v(var.as<ActivatedNRCellList>()); return true;
35988 case 2: v(var.as<ActivationID>()); return true;
35989 case 3: v(var.as<CriticalityDiagnostics>()); return true;
35995 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35996 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35999 char dummy1[sizeof(ActivatedNRCellList)];
36000 char dummy2[sizeof(ActivationID)];
36001 char dummy3[sizeof(CriticalityDiagnostics)];
36004 asn::variant<sizeof(union_type)> var;
36008 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
36010 size_t get_index() const {return type;}
36011 bool is_unknown() const { return type == 4; }
36012 void clear() {type = 0;}
36013 void select_id_ActivatedNRCellList() { set(mandatory); type=1;}
36014 void select_id_ActivationID() { set(mandatory); type=2;}
36015 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
36016 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
36017 template<typename V> bool decode(V& v)
36020 if(!v(ref_nested())) return false;
36021 if(equal(mandatory)) { type = 1; return true; }
36022 else if(equal(mandatory)) { type = 2; return true; }
36023 else if(equal(optional)) { type = 3; return true; }
36024 else { type = 4; return true;}
36028 template<typename V> bool encode(V& v) const
36030 return v(ref_nested());
36034 template<typename V> bool decode(size_t index, V& v)
36039 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
36040 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
36041 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
36042 case 4: type = 4; return v(ref_nested());
36043 ref_nested().clear();
36048 template<typename V> bool encode(size_t index, V& v) const
36050 if(index != type) {return false;} return v(ref_nested());
36060 ENDCCellActivationResponse ::= SEQUENCE {
36061 protocolIEs ProtocolIE-Container {{ENDCCellActivationResponse-IEs}},
36066 struct ENDCCellActivationResponse : asn::sequence<1, 0, true, 0>
36068 static constexpr const char* name() {return "ENDCCellActivationResponse";}
36069 using parent_t = asn::sequence<1, 0, true, 0>;
36070 struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationResponse_IEs>
36072 static constexpr const char* name() {return "protocolIEs_t";}
36073 using parent_t = ProtocolIE_Container<ENDCCellActivationResponse_IEs>;
36076 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
36077 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
36078 template<typename V> void decode(V& v)
36083 template<typename V> void encode(V& v) const
36090 protocolIEs.clear();
36094 protocolIEs_t protocolIEs;
36098 FDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36103 struct FDD_InfoServedNRCell_Information_ExtIEs
36105 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36107 size_t get_index() const {return type;}
36108 bool is_unknown() const { return type == 1; }
36109 void clear() {type = 0;}
36110 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36111 template<typename V> bool decode(V& v)
36114 if(!v(ref_nested())) return false;
36115 { type = 1; return true;}
36119 template<typename V> bool encode(V& v) const
36121 return v(ref_nested());
36125 template<typename V> bool decode(size_t index, V& v)
36130 case 1: type = 1; return v(ref_nested());
36131 ref_nested().clear();
36136 template<typename V> bool encode(size_t index, V& v) const
36138 if(index != type) {return false;} return v(ref_nested());
36145 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36147 size_t get_index() const {return type;}
36148 bool is_unknown() const { return type == 1; }
36149 void clear() {type = 0;}
36150 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36151 template<typename V> bool decode(V& v)
36154 if(!v(ref_nested())) return false;
36155 { type = 1; return true;}
36159 template<typename V> bool encode(V& v) const
36161 return v(ref_nested());
36165 template<typename V> bool decode(size_t index, V& v)
36170 case 1: type = 1; return v(ref_nested());
36171 ref_nested().clear();
36176 template<typename V> bool encode(size_t index, V& v) const
36178 if(index != type) {return false;} return v(ref_nested());
36185 struct Extension_t : asn::typefield<true>
36187 ~Extension_t() {clear();}
36188 size_t get_index() const {return type;}
36189 bool is_unknown() const { return type == 1; }
36192 type = 0; ref_nested().clear();
36194 template<typename V> static inline void enumerate(V& v)
36199 template<typename V> bool decode(size_t index, V& v)
36204 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36209 template<typename V> bool encode(size_t index, V& v) const
36211 if(index != type) return false;
36219 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36221 size_t get_index() const {return type;}
36222 bool is_unknown() const { return type == 1; }
36223 void clear() {type = 0;}
36224 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36225 template<typename V> bool decode(V& v)
36228 if(!v(ref_nested())) return false;
36229 { type = 1; return true;}
36233 template<typename V> bool encode(V& v) const
36235 return v(ref_nested());
36239 template<typename V> bool decode(size_t index, V& v)
36244 case 1: type = 1; return v(ref_nested());
36245 ref_nested().clear();
36250 template<typename V> bool encode(size_t index, V& v) const
36252 if(index != type) {return false;} return v(ref_nested());
36262 FDD-InfoServedNRCell-Information ::= SEQUENCE {
36263 ul-NRFreqInfo NRFreqInfo,
36264 dl-NRFreqInfo NRFreqInfo,
36265 ul-NR-TxBW NR-TxBW,
36266 dl-NR-TxBW NR-TxBW,
36267 iE-Extensions ProtocolExtensionContainer { {FDD-InfoServedNRCell-Information-ExtIEs} } OPTIONAL,
36272 struct FDD_InfoServedNRCell_Information : asn::sequence<5, 0, true, 1>
36274 static constexpr const char* name() {return "FDD-InfoServedNRCell-Information";}
36275 using parent_t = asn::sequence<5, 0, true, 1>;
36276 struct ul_NRFreqInfo_t : NRFreqInfo
36278 static constexpr const char* name() {return "ul_NRFreqInfo_t";}
36279 using parent_t = NRFreqInfo;
36282 ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
36283 ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
36284 struct dl_NRFreqInfo_t : NRFreqInfo
36286 static constexpr const char* name() {return "dl_NRFreqInfo_t";}
36287 using parent_t = NRFreqInfo;
36290 dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
36291 dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
36292 struct ul_NR_TxBW_t : NR_TxBW
36294 static constexpr const char* name() {return "ul_NR_TxBW_t";}
36295 using parent_t = NR_TxBW;
36298 ul_NR_TxBW_t& ref_ul_NR_TxBW() {return ul_NR_TxBW;}
36299 ul_NR_TxBW_t const& ref_ul_NR_TxBW() const {return ul_NR_TxBW;}
36300 struct dl_NR_TxBW_t : NR_TxBW
36302 static constexpr const char* name() {return "dl_NR_TxBW_t";}
36303 using parent_t = NR_TxBW;
36306 dl_NR_TxBW_t& ref_dl_NR_TxBW() {return dl_NR_TxBW;}
36307 dl_NR_TxBW_t const& ref_dl_NR_TxBW() const {return dl_NR_TxBW;}
36308 struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoServedNRCell_Information_ExtIEs>
36310 static constexpr const char* name() {return "iE_Extensions_t";}
36311 using parent_t = ProtocolExtensionContainer<FDD_InfoServedNRCell_Information_ExtIEs>;
36312 static constexpr bool optional = true;
36315 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36316 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36317 template<typename V> void decode(V& v)
36326 template<typename V> void encode(V& v) const
36337 ul_NRFreqInfo.clear();
36338 dl_NRFreqInfo.clear();
36339 ul_NR_TxBW.clear();
36340 dl_NR_TxBW.clear();
36341 iE_Extensions.clear();
36345 ul_NRFreqInfo_t ul_NRFreqInfo;
36346 dl_NRFreqInfo_t dl_NRFreqInfo;
36347 ul_NR_TxBW_t ul_NR_TxBW;
36348 dl_NR_TxBW_t dl_NR_TxBW;
36349 iE_Extensions_t iE_Extensions;
36353 TDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36358 struct TDD_InfoServedNRCell_Information_ExtIEs
36360 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36362 size_t get_index() const {return type;}
36363 bool is_unknown() const { return type == 1; }
36364 void clear() {type = 0;}
36365 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36366 template<typename V> bool decode(V& v)
36369 if(!v(ref_nested())) return false;
36370 { type = 1; return true;}
36374 template<typename V> bool encode(V& v) const
36376 return v(ref_nested());
36380 template<typename V> bool decode(size_t index, V& v)
36385 case 1: type = 1; return v(ref_nested());
36386 ref_nested().clear();
36391 template<typename V> bool encode(size_t index, V& v) const
36393 if(index != type) {return false;} return v(ref_nested());
36400 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36402 size_t get_index() const {return type;}
36403 bool is_unknown() const { return type == 1; }
36404 void clear() {type = 0;}
36405 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36406 template<typename V> bool decode(V& v)
36409 if(!v(ref_nested())) return false;
36410 { type = 1; return true;}
36414 template<typename V> bool encode(V& v) const
36416 return v(ref_nested());
36420 template<typename V> bool decode(size_t index, V& v)
36425 case 1: type = 1; return v(ref_nested());
36426 ref_nested().clear();
36431 template<typename V> bool encode(size_t index, V& v) const
36433 if(index != type) {return false;} return v(ref_nested());
36440 struct Extension_t : asn::typefield<true>
36442 ~Extension_t() {clear();}
36443 size_t get_index() const {return type;}
36444 bool is_unknown() const { return type == 1; }
36447 type = 0; ref_nested().clear();
36449 template<typename V> static inline void enumerate(V& v)
36454 template<typename V> bool decode(size_t index, V& v)
36459 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36464 template<typename V> bool encode(size_t index, V& v) const
36466 if(index != type) return false;
36474 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36476 size_t get_index() const {return type;}
36477 bool is_unknown() const { return type == 1; }
36478 void clear() {type = 0;}
36479 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36480 template<typename V> bool decode(V& v)
36483 if(!v(ref_nested())) return false;
36484 { type = 1; return true;}
36488 template<typename V> bool encode(V& v) const
36490 return v(ref_nested());
36494 template<typename V> bool decode(size_t index, V& v)
36499 case 1: type = 1; return v(ref_nested());
36500 ref_nested().clear();
36505 template<typename V> bool encode(size_t index, V& v) const
36507 if(index != type) {return false;} return v(ref_nested());
36517 TDD-InfoServedNRCell-Information ::= SEQUENCE {
36518 nRFreqInfo NRFreqInfo,
36520 iE-Extensions ProtocolExtensionContainer { {TDD-InfoServedNRCell-Information-ExtIEs} } OPTIONAL,
36525 struct TDD_InfoServedNRCell_Information : asn::sequence<3, 0, true, 1>
36527 static constexpr const char* name() {return "TDD-InfoServedNRCell-Information";}
36528 using parent_t = asn::sequence<3, 0, true, 1>;
36529 struct nRFreqInfo_t : NRFreqInfo
36531 static constexpr const char* name() {return "nRFreqInfo_t";}
36532 using parent_t = NRFreqInfo;
36535 nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
36536 nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
36537 struct nR_TxBW_t : NR_TxBW
36539 static constexpr const char* name() {return "nR_TxBW_t";}
36540 using parent_t = NR_TxBW;
36543 nR_TxBW_t& ref_nR_TxBW() {return nR_TxBW;}
36544 nR_TxBW_t const& ref_nR_TxBW() const {return nR_TxBW;}
36545 struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoServedNRCell_Information_ExtIEs>
36547 static constexpr const char* name() {return "iE_Extensions_t";}
36548 using parent_t = ProtocolExtensionContainer<TDD_InfoServedNRCell_Information_ExtIEs>;
36549 static constexpr bool optional = true;
36552 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36553 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36554 template<typename V> void decode(V& v)
36561 template<typename V> void encode(V& v) const
36570 nRFreqInfo.clear();
36572 iE_Extensions.clear();
36576 nRFreqInfo_t nRFreqInfo;
36578 iE_Extensions_t iE_Extensions;
36582 ServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36587 struct ServedNRCell_Information_ExtIEs
36589 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36591 size_t get_index() const {return type;}
36592 bool is_unknown() const { return type == 1; }
36593 void clear() {type = 0;}
36594 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36595 template<typename V> bool decode(V& v)
36598 if(!v(ref_nested())) return false;
36599 { type = 1; return true;}
36603 template<typename V> bool encode(V& v) const
36605 return v(ref_nested());
36609 template<typename V> bool decode(size_t index, V& v)
36614 case 1: type = 1; return v(ref_nested());
36615 ref_nested().clear();
36620 template<typename V> bool encode(size_t index, V& v) const
36622 if(index != type) {return false;} return v(ref_nested());
36629 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36631 size_t get_index() const {return type;}
36632 bool is_unknown() const { return type == 1; }
36633 void clear() {type = 0;}
36634 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36635 template<typename V> bool decode(V& v)
36638 if(!v(ref_nested())) return false;
36639 { type = 1; return true;}
36643 template<typename V> bool encode(V& v) const
36645 return v(ref_nested());
36649 template<typename V> bool decode(size_t index, V& v)
36654 case 1: type = 1; return v(ref_nested());
36655 ref_nested().clear();
36660 template<typename V> bool encode(size_t index, V& v) const
36662 if(index != type) {return false;} return v(ref_nested());
36669 struct Extension_t : asn::typefield<true>
36671 ~Extension_t() {clear();}
36672 size_t get_index() const {return type;}
36673 bool is_unknown() const { return type == 1; }
36676 type = 0; ref_nested().clear();
36678 template<typename V> static inline void enumerate(V& v)
36683 template<typename V> bool decode(size_t index, V& v)
36688 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36693 template<typename V> bool encode(size_t index, V& v) const
36695 if(index != type) return false;
36703 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36705 size_t get_index() const {return type;}
36706 bool is_unknown() const { return type == 1; }
36707 void clear() {type = 0;}
36708 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36709 template<typename V> bool decode(V& v)
36712 if(!v(ref_nested())) return false;
36713 { type = 1; return true;}
36717 template<typename V> bool encode(V& v) const
36719 return v(ref_nested());
36723 template<typename V> bool decode(size_t index, V& v)
36728 case 1: type = 1; return v(ref_nested());
36729 ref_nested().clear();
36734 template<typename V> bool encode(size_t index, V& v) const
36736 if(index != type) {return false;} return v(ref_nested());
36746 ServedNRCell-Information ::= SEQUENCE {
36749 fiveGS-TAC FiveGS-TAC OPTIONAL,
36750 configured-TAC TAC OPTIONAL,
36751 broadcastPLMNs BroadcastPLMNs-Item,
36752 nrModeInfo CHOICE {
36753 fdd FDD-InfoServedNRCell-Information,
36754 tdd TDD-InfoServedNRCell-Information,
36757 measurementTimingConfiguration OCTET STRING,
36758 iE-Extensions ProtocolExtensionContainer { {ServedNRCell-Information-ExtIEs} } OPTIONAL,
36763 struct ServedNRCell_Information : asn::sequence<8, 0, true, 3>
36765 static constexpr const char* name() {return "ServedNRCell-Information";}
36766 using parent_t = asn::sequence<8, 0, true, 3>;
36767 struct nrpCI_t : NRPCI
36769 static constexpr const char* name() {return "nrpCI_t";}
36770 using parent_t = NRPCI;
36773 nrpCI_t& ref_nrpCI() {return nrpCI;}
36774 nrpCI_t const& ref_nrpCI() const {return nrpCI;}
36775 struct nrCellID_t : NRCGI
36777 static constexpr const char* name() {return "nrCellID_t";}
36778 using parent_t = NRCGI;
36781 nrCellID_t& ref_nrCellID() {return nrCellID;}
36782 nrCellID_t const& ref_nrCellID() const {return nrCellID;}
36783 struct fiveGS_TAC_t : FiveGS_TAC
36785 static constexpr const char* name() {return "fiveGS_TAC_t";}
36786 using parent_t = FiveGS_TAC;
36787 static constexpr bool optional = true;
36790 fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
36791 fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
36792 struct configured_TAC_t : TAC
36794 static constexpr const char* name() {return "configured_TAC_t";}
36795 using parent_t = TAC;
36796 static constexpr bool optional = true;
36799 configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
36800 configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
36801 struct broadcastPLMNs_t : BroadcastPLMNs_Item
36803 static constexpr const char* name() {return "broadcastPLMNs_t";}
36804 using parent_t = BroadcastPLMNs_Item;
36807 broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
36808 broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
36809 struct nrModeInfo_t : asn::choice<2, 0, true>
36811 static constexpr const char* name() {return "nrModeInfo_t";}
36812 using parent_t = asn::choice<2, 0, true>;
36813 index_type get_index() const {return index;}
36814 bool is_unknown() const {return index == 3;}
36815 void set_unknown() { set_index(3); }
36816 ~nrModeInfo_t() {clear();}
36817 struct fdd_t : FDD_InfoServedNRCell_Information
36819 static constexpr const char* name() {return "fdd_t";}
36820 using parent_t = FDD_InfoServedNRCell_Information;
36823 struct tdd_t : TDD_InfoServedNRCell_Information
36825 static constexpr const char* name() {return "tdd_t";}
36826 using parent_t = TDD_InfoServedNRCell_Information;
36831 switch(get_index())
36833 case 1: var.destroy<fdd_t>(); break;
36834 case 2: var.destroy<tdd_t>(); break;
36839 template<typename V> bool decode(size_t idx, V& v)
36844 case 1: set_index(1); return v(var.build<fdd_t>());
36845 case 2: set_index(2); return v(var.build<tdd_t>());
36850 template<typename V> bool encode(V& v) const
36852 switch(get_index())
36854 case 1: return v(var.as<fdd_t>());
36855 case 2: return v(var.as<tdd_t>());
36859 template<typename V> static inline void enumerate(V& v)
36861 v.template operator()<fdd_t>(1);
36862 v.template operator()<tdd_t>(2);
36865 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
36866 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
36867 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
36868 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
36870 void set_index(index_type i) {index = i; base::set();}
36873 char dummy1[sizeof(fdd_t)];
36874 char dummy2[sizeof(tdd_t)];
36877 asn::variant<sizeof(union_type)> var;
36878 index_type index {0};
36880 nrModeInfo_t& ref_nrModeInfo() {return nrModeInfo;}
36881 nrModeInfo_t const& ref_nrModeInfo() const {return nrModeInfo;}
36882 struct measurementTimingConfiguration_t : asn::ostring<>
36884 static constexpr const char* name() {return "measurementTimingConfiguration_t";}
36885 using parent_t = asn::ostring<>;
36889 measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
36890 measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
36891 struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCell_Information_ExtIEs>
36893 static constexpr const char* name() {return "iE_Extensions_t";}
36894 using parent_t = ProtocolExtensionContainer<ServedNRCell_Information_ExtIEs>;
36895 static constexpr bool optional = true;
36898 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36899 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36900 template<typename V> void decode(V& v)
36908 v(measurementTimingConfiguration);
36912 template<typename V> void encode(V& v) const
36920 v(measurementTimingConfiguration);
36928 fiveGS_TAC.clear();
36929 configured_TAC.clear();
36930 broadcastPLMNs.clear();
36931 nrModeInfo.clear();
36932 measurementTimingConfiguration.clear();
36933 iE_Extensions.clear();
36938 nrCellID_t nrCellID;
36939 fiveGS_TAC_t fiveGS_TAC;
36940 configured_TAC_t configured_TAC;
36941 broadcastPLMNs_t broadcastPLMNs;
36942 nrModeInfo_t nrModeInfo;
36943 measurementTimingConfiguration_t measurementTimingConfiguration;
36944 iE_Extensions_t iE_Extensions;
36948 En-gNBServedCells-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36953 struct En_gNBServedCells_ExtIEs
36955 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36957 size_t get_index() const {return type;}
36958 bool is_unknown() const { return type == 1; }
36959 void clear() {type = 0;}
36960 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36961 template<typename V> bool decode(V& v)
36964 if(!v(ref_nested())) return false;
36965 { type = 1; return true;}
36969 template<typename V> bool encode(V& v) const
36971 return v(ref_nested());
36975 template<typename V> bool decode(size_t index, V& v)
36980 case 1: type = 1; return v(ref_nested());
36981 ref_nested().clear();
36986 template<typename V> bool encode(size_t index, V& v) const
36988 if(index != type) {return false;} return v(ref_nested());
36995 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36997 size_t get_index() const {return type;}
36998 bool is_unknown() const { return type == 1; }
36999 void clear() {type = 0;}
37000 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
37001 template<typename V> bool decode(V& v)
37004 if(!v(ref_nested())) return false;
37005 { type = 1; return true;}
37009 template<typename V> bool encode(V& v) const
37011 return v(ref_nested());
37015 template<typename V> bool decode(size_t index, V& v)
37020 case 1: type = 1; return v(ref_nested());
37021 ref_nested().clear();
37026 template<typename V> bool encode(size_t index, V& v) const
37028 if(index != type) {return false;} return v(ref_nested());
37035 struct Extension_t : asn::typefield<true>
37037 ~Extension_t() {clear();}
37038 size_t get_index() const {return type;}
37039 bool is_unknown() const { return type == 1; }
37042 type = 0; ref_nested().clear();
37044 template<typename V> static inline void enumerate(V& v)
37049 template<typename V> bool decode(size_t index, V& v)
37054 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
37059 template<typename V> bool encode(size_t index, V& v) const
37061 if(index != type) return false;
37069 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
37071 size_t get_index() const {return type;}
37072 bool is_unknown() const { return type == 1; }
37073 void clear() {type = 0;}
37074 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
37075 template<typename V> bool decode(V& v)
37078 if(!v(ref_nested())) return false;
37079 { type = 1; return true;}
37083 template<typename V> bool encode(V& v) const
37085 return v(ref_nested());
37089 template<typename V> bool decode(size_t index, V& v)
37094 case 1: type = 1; return v(ref_nested());
37095 ref_nested().clear();
37100 template<typename V> bool encode(size_t index, V& v) const
37102 if(index != type) {return false;} return v(ref_nested());
37112 ServedNRcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF SEQUENCE {
37113 servedNRCellInfo ServedNRCell-Information,
37114 nRNeighbourInfo NRNeighbour-Information OPTIONAL,
37115 iE-Extensions ProtocolExtensionContainer { {En-gNBServedCells-ExtIEs} } OPTIONAL,
37120 struct ServedNRcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
37122 static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList_elm";}
37123 using parent_t = asn::sequence<3, 0, true, 2>;
37124 struct servedNRCellInfo_t : ServedNRCell_Information
37126 static constexpr const char* name() {return "servedNRCellInfo_t";}
37127 using parent_t = ServedNRCell_Information;
37130 servedNRCellInfo_t& ref_servedNRCellInfo() {return servedNRCellInfo;}
37131 servedNRCellInfo_t const& ref_servedNRCellInfo() const {return servedNRCellInfo;}
37132 struct nRNeighbourInfo_t : NRNeighbour_Information
37134 static constexpr const char* name() {return "nRNeighbourInfo_t";}
37135 using parent_t = NRNeighbour_Information;
37136 static constexpr bool optional = true;
37139 nRNeighbourInfo_t& set_nRNeighbourInfo() { nRNeighbourInfo.setpresent(true); return nRNeighbourInfo;}
37140 nRNeighbourInfo_t const* get_nRNeighbourInfo() const {return nRNeighbourInfo.is_valid() ? &nRNeighbourInfo : nullptr;}
37141 struct iE_Extensions_t : ProtocolExtensionContainer<En_gNBServedCells_ExtIEs>
37143 static constexpr const char* name() {return "iE_Extensions_t";}
37144 using parent_t = ProtocolExtensionContainer<En_gNBServedCells_ExtIEs>;
37145 static constexpr bool optional = true;
37148 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
37149 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
37150 template<typename V> void decode(V& v)
37152 v(servedNRCellInfo);
37153 v(nRNeighbourInfo);
37157 template<typename V> void encode(V& v) const
37159 v(servedNRCellInfo);
37160 v(nRNeighbourInfo);
37166 servedNRCellInfo.clear();
37167 nRNeighbourInfo.clear();
37168 iE_Extensions.clear();
37172 servedNRCellInfo_t servedNRCellInfo;
37173 nRNeighbourInfo_t nRNeighbourInfo;
37174 iE_Extensions_t iE_Extensions;
37177 struct ServedNRcellsENDCX2ManagementList : asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>
37179 static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList";}
37180 using parent_t = asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>;
37181 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
37185 ServedNRCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
37190 struct ServedNRCellsToModify_Item_ExtIEs
37192 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
37194 size_t get_index() const {return type;}
37195 bool is_unknown() const { return type == 1; }
37196 void clear() {type = 0;}
37197 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
37198 template<typename V> bool decode(V& v)
37201 if(!v(ref_nested())) return false;
37202 { type = 1; return true;}
37206 template<typename V> bool encode(V& v) const
37208 return v(ref_nested());
37212 template<typename V> bool decode(size_t index, V& v)
37217 case 1: type = 1; return v(ref_nested());
37218 ref_nested().clear();
37223 template<typename V> bool encode(size_t index, V& v) const
37225 if(index != type) {return false;} return v(ref_nested());
37232 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
37234 size_t get_index() const {return type;}
37235 bool is_unknown() const { return type == 1; }
37236 void clear() {type = 0;}
37237 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
37238 template<typename V> bool decode(V& v)
37241 if(!v(ref_nested())) return false;
37242 { type = 1; return true;}
37246 template<typename V> bool encode(V& v) const
37248 return v(ref_nested());
37252 template<typename V> bool decode(size_t index, V& v)
37257 case 1: type = 1; return v(ref_nested());
37258 ref_nested().clear();
37263 template<typename V> bool encode(size_t index, V& v) const
37265 if(index != type) {return false;} return v(ref_nested());
37272 struct Extension_t : asn::typefield<true>
37274 ~Extension_t() {clear();}
37275 size_t get_index() const {return type;}
37276 bool is_unknown() const { return type == 1; }
37279 type = 0; ref_nested().clear();
37281 template<typename V> static inline void enumerate(V& v)
37286 template<typename V> bool decode(size_t index, V& v)
37291 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
37296 template<typename V> bool encode(size_t index, V& v) const
37298 if(index != type) return false;
37306 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
37308 size_t get_index() const {return type;}
37309 bool is_unknown() const { return type == 1; }
37310 void clear() {type = 0;}
37311 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
37312 template<typename V> bool decode(V& v)
37315 if(!v(ref_nested())) return false;
37316 { type = 1; return true;}
37320 template<typename V> bool encode(V& v) const
37322 return v(ref_nested());
37326 template<typename V> bool decode(size_t index, V& v)
37331 case 1: type = 1; return v(ref_nested());
37332 ref_nested().clear();
37337 template<typename V> bool encode(size_t index, V& v) const
37339 if(index != type) {return false;} return v(ref_nested());
37349 ServedNRCellsToModify-Item::= SEQUENCE {
37351 servedNRCellInformation ServedNRCell-Information,
37352 nrNeighbourInformation NRNeighbour-Information OPTIONAL,
37353 nrDeactivationIndication DeactivationIndication OPTIONAL,
37354 iE-Extensions ProtocolExtensionContainer { {ServedNRCellsToModify-Item-ExtIEs} } OPTIONAL,
37359 struct ServedNRCellsToModify_Item : asn::sequence<5, 0, true, 3>
37361 static constexpr const char* name() {return "ServedNRCellsToModify-Item";}
37362 using parent_t = asn::sequence<5, 0, true, 3>;
37363 struct old_nrcgi_t : NRCGI
37365 static constexpr const char* name() {return "old_nrcgi_t";}
37366 using parent_t = NRCGI;
37369 old_nrcgi_t& ref_old_nrcgi() {return old_nrcgi;}
37370 old_nrcgi_t const& ref_old_nrcgi() const {return old_nrcgi;}
37371 struct servedNRCellInformation_t : ServedNRCell_Information
37373 static constexpr const char* name() {return "servedNRCellInformation_t";}
37374 using parent_t = ServedNRCell_Information;
37377 servedNRCellInformation_t& ref_servedNRCellInformation() {return servedNRCellInformation;}
37378 servedNRCellInformation_t const& ref_servedNRCellInformation() const {return servedNRCellInformation;}
37379 struct nrNeighbourInformation_t : NRNeighbour_Information
37381 static constexpr const char* name() {return "nrNeighbourInformation_t";}
37382 using parent_t = NRNeighbour_Information;
37383 static constexpr bool optional = true;
37386 nrNeighbourInformation_t& set_nrNeighbourInformation() { nrNeighbourInformation.setpresent(true); return nrNeighbourInformation;}
37387 nrNeighbourInformation_t const* get_nrNeighbourInformation() const {return nrNeighbourInformation.is_valid() ? &nrNeighbourInformation : nullptr;}
37388 struct nrDeactivationIndication_t : DeactivationIndication
37390 static constexpr const char* name() {return "nrDeactivationIndication_t";}
37391 using parent_t = DeactivationIndication;
37392 static constexpr bool optional = true;
37395 nrDeactivationIndication_t& set_nrDeactivationIndication() { nrDeactivationIndication.setpresent(true); return nrDeactivationIndication;}
37396 nrDeactivationIndication_t const* get_nrDeactivationIndication() const {return nrDeactivationIndication.is_valid() ? &nrDeactivationIndication : nullptr;}
37397 struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToModify_Item_ExtIEs>
37399 static constexpr const char* name() {return "iE_Extensions_t";}
37400 using parent_t = ProtocolExtensionContainer<ServedNRCellsToModify_Item_ExtIEs>;
37401 static constexpr bool optional = true;
37404 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
37405 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
37406 template<typename V> void decode(V& v)
37409 v(servedNRCellInformation);
37410 v(nrNeighbourInformation);
37411 v(nrDeactivationIndication);
37415 template<typename V> void encode(V& v) const
37418 v(servedNRCellInformation);
37419 v(nrNeighbourInformation);
37420 v(nrDeactivationIndication);
37427 servedNRCellInformation.clear();
37428 nrNeighbourInformation.clear();
37429 nrDeactivationIndication.clear();
37430 iE_Extensions.clear();
37434 old_nrcgi_t old_nrcgi;
37435 servedNRCellInformation_t servedNRCellInformation;
37436 nrNeighbourInformation_t nrNeighbourInformation;
37437 nrDeactivationIndication_t nrDeactivationIndication;
37438 iE_Extensions_t iE_Extensions;
37442 ServedNRcellsToModifyENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF ServedNRCellsToModify-Item
37445 struct ServedNRcellsToModifyENDCConfUpdList_elm : ServedNRCellsToModify_Item
37447 static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList_elm";}
37448 using parent_t = ServedNRCellsToModify_Item;
37451 struct ServedNRcellsToModifyENDCConfUpdList : asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>
37453 static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList";}
37454 using parent_t = asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>;
37455 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
37459 ServedNRcellsToDeleteENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF NRCGI
37462 struct ServedNRcellsToDeleteENDCConfUpdList_elm : NRCGI
37464 static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList_elm";}
37465 using parent_t = NRCGI;
37468 struct ServedNRcellsToDeleteENDCConfUpdList : asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>
37470 static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList";}
37471 using parent_t = asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>;
37472 using constraint_t = asn::constraints<false,asn::span<1, maxCellinengNB >>;
37476 En-gNB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
37477 { ID id-ServedNRcellsENDCX2ManagementList CRITICALITY reject TYPE ServedNRcellsENDCX2ManagementList PRESENCE optional }|
37478 { ID id-ServedNRcellsToModifyListENDCConfUpd CRITICALITY reject TYPE ServedNRcellsToModifyENDCConfUpdList PRESENCE optional }|
37479 { ID id-ServedNRcellsToDeleteListENDCConfUpd CRITICALITY reject TYPE ServedNRcellsToDeleteENDCConfUpdList PRESENCE optional },
37484 struct En_gNB_ENDCConfigUpdateIEs
37486 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
37488 size_t get_index() const {return type;}
37489 bool is_unknown() const { return type == 4; }
37490 void clear() {type = 0;}
37491 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=1;}
37492 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(id_ServedNRcellsToModifyListENDCConfUpd); type=2;}
37493 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(id_ServedNRcellsToDeleteListENDCConfUpd); type=3;}
37494 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
37495 template<typename V> bool decode(V& v)
37498 if(!v(ref_nested())) return false;
37499 if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 1; return true; }
37500 else if(equal(id_ServedNRcellsToModifyListENDCConfUpd)) { type = 2; return true; }
37501 else if(equal(id_ServedNRcellsToDeleteListENDCConfUpd)) { type = 3; return true; }
37502 else { type = 4; return true;}
37506 template<typename V> bool encode(V& v) const
37508 return v(ref_nested());
37512 template<typename V> bool decode(size_t index, V& v)
37517 case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
37518 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsToModifyListENDCConfUpd);} return false;
37519 case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedNRcellsToDeleteListENDCConfUpd);} return false;
37520 case 4: type = 4; return v(ref_nested());
37521 ref_nested().clear();
37526 template<typename V> bool encode(size_t index, V& v) const
37528 if(index != type) {return false;} return v(ref_nested());
37535 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
37537 size_t get_index() const {return type;}
37538 bool is_unknown() const { return type == 4; }
37539 void clear() {type = 0;}
37540 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=1;}
37541 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(reject); type=2;}
37542 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(reject); type=3;}
37543 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
37544 template<typename V> bool decode(V& v)
37547 if(!v(ref_nested())) return false;
37548 if(equal(reject)) { type = 1; return true; }
37549 else if(equal(reject)) { type = 2; return true; }
37550 else if(equal(reject)) { type = 3; return true; }
37551 else { type = 4; return true;}
37555 template<typename V> bool encode(V& v) const
37557 return v(ref_nested());
37561 template<typename V> bool decode(size_t index, V& v)
37566 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
37567 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
37568 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
37569 case 4: type = 4; return v(ref_nested());
37570 ref_nested().clear();
37575 template<typename V> bool encode(size_t index, V& v) const
37577 if(index != type) {return false;} return v(ref_nested());
37584 struct Value_t : asn::typefield<true>
37586 ~Value_t() {clear();}
37587 size_t get_index() const {return type;}
37588 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
37589 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
37590 ServedNRcellsToModifyENDCConfUpdList& select_id_ServedNRcellsToModifyListENDCConfUpd() { return set<ServedNRcellsToModifyENDCConfUpdList>(2); }
37591 ServedNRcellsToModifyENDCConfUpdList const* get_id_ServedNRcellsToModifyListENDCConfUpd() const { return get<ServedNRcellsToModifyENDCConfUpdList>(2); }
37592 ServedNRcellsToDeleteENDCConfUpdList& select_id_ServedNRcellsToDeleteListENDCConfUpd() { return set<ServedNRcellsToDeleteENDCConfUpdList>(3); }
37593 ServedNRcellsToDeleteENDCConfUpdList const* get_id_ServedNRcellsToDeleteListENDCConfUpd() const { return get<ServedNRcellsToDeleteENDCConfUpdList>(3); }
37594 bool is_unknown() const { return type == 4; }
37599 case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
37600 case 2: var.destroy<ServedNRcellsToModifyENDCConfUpdList>(); break;
37601 case 3: var.destroy<ServedNRcellsToDeleteENDCConfUpdList>(); break;
37603 type = 0; ref_nested().clear();
37605 template<typename V> static inline void enumerate(V& v)
37607 v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
37608 v.template operator()<ServedNRcellsToModifyENDCConfUpdList>(2);
37609 v.template operator()<ServedNRcellsToDeleteENDCConfUpdList>(3);
37613 template<typename V> bool decode(size_t index, V& v)
37618 case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
37619 case 2: v(select_id_ServedNRcellsToModifyListENDCConfUpd()); return true;
37620 case 3: v(select_id_ServedNRcellsToDeleteListENDCConfUpd()); return true;
37621 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
37626 template<typename V> bool encode(size_t index, V& v) const
37628 if(index != type) return false;
37631 case 1: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
37632 case 2: v(var.as<ServedNRcellsToModifyENDCConfUpdList>()); return true;
37633 case 3: v(var.as<ServedNRcellsToDeleteENDCConfUpdList>()); return true;
37639 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
37640 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
37643 char dummy1[sizeof(ServedNRcellsENDCX2ManagementList)];
37644 char dummy2[sizeof(ServedNRcellsToDeleteENDCConfUpdList)];
37645 char dummy3[sizeof(ServedNRcellsToModifyENDCConfUpdList)];
37648 asn::variant<sizeof(union_type)> var;
37652 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
37654 size_t get_index() const {return type;}
37655 bool is_unknown() const { return type == 4; }
37656 void clear() {type = 0;}
37657 void select_id_ServedNRcellsENDCX2ManagementList() { set(optional); type=1;}
37658 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(optional); type=2;}
37659 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(optional); type=3;}
37660 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
37661 template<typename V> bool decode(V& v)
37664 if(!v(ref_nested())) return false;
37665 if(equal(optional)) { type = 1; return true; }
37666 else if(equal(optional)) { type = 2; return true; }
37667 else if(equal(optional)) { type = 3; return true; }
37668 else { type = 4; return true;}
37672 template<typename V> bool encode(V& v) const
37674 return v(ref_nested());
37678 template<typename V> bool decode(size_t index, V& v)
37683 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
37684 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
37685 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
37686 case 4: type = 4; return v(ref_nested());
37687 ref_nested().clear();
37692 template<typename V> bool encode(size_t index, V& v) const
37694 if(index != type) {return false;} return v(ref_nested());
37704 InitiatingNodeType-EndcConfigUpdate::= CHOICE {
37705 init-eNB ProtocolIE-Container {{ENB-ENDCConfigUpdateIEs}},
37706 init-en-gNB ProtocolIE-Container {{En-gNB-ENDCConfigUpdateIEs}},
37711 struct InitiatingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
37713 static constexpr const char* name() {return "InitiatingNodeType-EndcConfigUpdate";}
37714 using parent_t = asn::choice<2, 0, true>;
37715 index_type get_index() const {return index;}
37716 bool is_unknown() const {return index == 3;}
37717 void set_unknown() { set_index(3); }
37718 ~InitiatingNodeType_EndcConfigUpdate() {clear();}
37719 struct init_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>
37721 static constexpr const char* name() {return "init_eNB_t";}
37722 using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>;
37725 struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>
37727 static constexpr const char* name() {return "init_en_gNB_t";}
37728 using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>;
37733 switch(get_index())
37735 case 1: var.destroy<init_eNB_t>(); break;
37736 case 2: var.destroy<init_en_gNB_t>(); break;
37741 template<typename V> bool decode(size_t idx, V& v)
37746 case 1: set_index(1); return v(var.build<init_eNB_t>());
37747 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
37752 template<typename V> bool encode(V& v) const
37754 switch(get_index())
37756 case 1: return v(var.as<init_eNB_t>());
37757 case 2: return v(var.as<init_en_gNB_t>());
37761 template<typename V> static inline void enumerate(V& v)
37763 v.template operator()<init_eNB_t>(1);
37764 v.template operator()<init_en_gNB_t>(2);
37767 init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
37768 init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
37769 init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
37770 init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
37772 void set_index(index_type i) {index = i; base::set();}
37775 char dummy1[sizeof(init_eNB_t)];
37776 char dummy2[sizeof(init_en_gNB_t)];
37779 asn::variant<sizeof(union_type)> var;
37780 index_type index {0};
37783 ENDCConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
37784 { ID id-InitiatingNodeType-EndcConfigUpdate CRITICALITY reject TYPE InitiatingNodeType-EndcConfigUpdate PRESENCE mandatory},
37789 struct ENDCConfigurationUpdate_IEs
37791 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
37793 size_t get_index() const {return type;}
37794 bool is_unknown() const { return type == 2; }
37795 void clear() {type = 0;}
37796 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(id_InitiatingNodeType_EndcConfigUpdate); type=1;}
37797 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
37798 template<typename V> bool decode(V& v)
37801 if(!v(ref_nested())) return false;
37802 if(equal(id_InitiatingNodeType_EndcConfigUpdate)) { type = 1; return true; }
37803 else { type = 2; return true;}
37807 template<typename V> bool encode(V& v) const
37809 return v(ref_nested());
37813 template<typename V> bool decode(size_t index, V& v)
37818 case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcConfigUpdate);} return false;
37819 case 2: type = 2; return v(ref_nested());
37820 ref_nested().clear();
37825 template<typename V> bool encode(size_t index, V& v) const
37827 if(index != type) {return false;} return v(ref_nested());
37834 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
37836 size_t get_index() const {return type;}
37837 bool is_unknown() const { return type == 2; }
37838 void clear() {type = 0;}
37839 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(reject); type=1;}
37840 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
37841 template<typename V> bool decode(V& v)
37844 if(!v(ref_nested())) return false;
37845 if(equal(reject)) { type = 1; return true; }
37846 else { type = 2; return true;}
37850 template<typename V> bool encode(V& v) const
37852 return v(ref_nested());
37856 template<typename V> bool decode(size_t index, V& v)
37861 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
37862 case 2: type = 2; return v(ref_nested());
37863 ref_nested().clear();
37868 template<typename V> bool encode(size_t index, V& v) const
37870 if(index != type) {return false;} return v(ref_nested());
37877 struct Value_t : asn::typefield<true>
37879 ~Value_t() {clear();}
37880 size_t get_index() const {return type;}
37881 InitiatingNodeType_EndcConfigUpdate& select_id_InitiatingNodeType_EndcConfigUpdate() { return set<InitiatingNodeType_EndcConfigUpdate>(1); }
37882 InitiatingNodeType_EndcConfigUpdate const* get_id_InitiatingNodeType_EndcConfigUpdate() const { return get<InitiatingNodeType_EndcConfigUpdate>(1); }
37883 bool is_unknown() const { return type == 2; }
37888 case 1: var.destroy<InitiatingNodeType_EndcConfigUpdate>(); break;
37890 type = 0; ref_nested().clear();
37892 template<typename V> static inline void enumerate(V& v)
37894 v.template operator()<InitiatingNodeType_EndcConfigUpdate>(1);
37898 template<typename V> bool decode(size_t index, V& v)
37903 case 1: v(select_id_InitiatingNodeType_EndcConfigUpdate()); return true;
37904 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
37909 template<typename V> bool encode(size_t index, V& v) const
37911 if(index != type) return false;
37914 case 1: v(var.as<InitiatingNodeType_EndcConfigUpdate>()); return true;
37920 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
37921 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
37924 char dummy1[sizeof(InitiatingNodeType_EndcConfigUpdate)];
37927 asn::variant<sizeof(union_type)> var;
37931 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
37933 size_t get_index() const {return type;}
37934 bool is_unknown() const { return type == 2; }
37935 void clear() {type = 0;}
37936 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(mandatory); type=1;}
37937 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
37938 template<typename V> bool decode(V& v)
37941 if(!v(ref_nested())) return false;
37942 if(equal(mandatory)) { type = 1; return true; }
37943 else { type = 2; return true;}
37947 template<typename V> bool encode(V& v) const
37949 return v(ref_nested());
37953 template<typename V> bool decode(size_t index, V& v)
37958 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
37959 case 2: type = 2; return v(ref_nested());
37960 ref_nested().clear();
37965 template<typename V> bool encode(size_t index, V& v) const
37967 if(index != type) {return false;} return v(ref_nested());
37977 ENDCConfigurationUpdate ::= SEQUENCE {
37978 protocolIEs ProtocolIE-Container {{ENDCConfigurationUpdate-IEs}},
37983 struct ENDCConfigurationUpdate : asn::sequence<1, 0, true, 0>
37985 static constexpr const char* name() {return "ENDCConfigurationUpdate";}
37986 using parent_t = asn::sequence<1, 0, true, 0>;
37987 struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdate_IEs>
37989 static constexpr const char* name() {return "protocolIEs_t";}
37990 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdate_IEs>;
37993 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
37994 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
37995 template<typename V> void decode(V& v)
38000 template<typename V> void encode(V& v) const
38007 protocolIEs.clear();
38011 protocolIEs_t protocolIEs;
38015 En-gNB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
38016 { ID id-ServedNRcellsENDCX2ManagementList CRITICALITY reject TYPE ServedNRcellsENDCX2ManagementList PRESENCE optional},
38021 struct En_gNB_ENDCConfigUpdateAckIEs
38023 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38025 size_t get_index() const {return type;}
38026 bool is_unknown() const { return type == 2; }
38027 void clear() {type = 0;}
38028 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=1;}
38029 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38030 template<typename V> bool decode(V& v)
38033 if(!v(ref_nested())) return false;
38034 if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 1; return true; }
38035 else { type = 2; return true;}
38039 template<typename V> bool encode(V& v) const
38041 return v(ref_nested());
38045 template<typename V> bool decode(size_t index, V& v)
38050 case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
38051 case 2: type = 2; return v(ref_nested());
38052 ref_nested().clear();
38057 template<typename V> bool encode(size_t index, V& v) const
38059 if(index != type) {return false;} return v(ref_nested());
38066 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38068 size_t get_index() const {return type;}
38069 bool is_unknown() const { return type == 2; }
38070 void clear() {type = 0;}
38071 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=1;}
38072 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38073 template<typename V> bool decode(V& v)
38076 if(!v(ref_nested())) return false;
38077 if(equal(reject)) { type = 1; return true; }
38078 else { type = 2; return true;}
38082 template<typename V> bool encode(V& v) const
38084 return v(ref_nested());
38088 template<typename V> bool decode(size_t index, V& v)
38093 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38094 case 2: type = 2; return v(ref_nested());
38095 ref_nested().clear();
38100 template<typename V> bool encode(size_t index, V& v) const
38102 if(index != type) {return false;} return v(ref_nested());
38109 struct Value_t : asn::typefield<true>
38111 ~Value_t() {clear();}
38112 size_t get_index() const {return type;}
38113 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
38114 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
38115 bool is_unknown() const { return type == 2; }
38120 case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
38122 type = 0; ref_nested().clear();
38124 template<typename V> static inline void enumerate(V& v)
38126 v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
38130 template<typename V> bool decode(size_t index, V& v)
38135 case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
38136 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38141 template<typename V> bool encode(size_t index, V& v) const
38143 if(index != type) return false;
38146 case 1: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
38152 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38153 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38156 char dummy1[sizeof(ServedNRcellsENDCX2ManagementList)];
38159 asn::variant<sizeof(union_type)> var;
38163 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38165 size_t get_index() const {return type;}
38166 bool is_unknown() const { return type == 2; }
38167 void clear() {type = 0;}
38168 void select_id_ServedNRcellsENDCX2ManagementList() { set(optional); type=1;}
38169 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38170 template<typename V> bool decode(V& v)
38173 if(!v(ref_nested())) return false;
38174 if(equal(optional)) { type = 1; return true; }
38175 else { type = 2; return true;}
38179 template<typename V> bool encode(V& v) const
38181 return v(ref_nested());
38185 template<typename V> bool decode(size_t index, V& v)
38190 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
38191 case 2: type = 2; return v(ref_nested());
38192 ref_nested().clear();
38197 template<typename V> bool encode(size_t index, V& v) const
38199 if(index != type) {return false;} return v(ref_nested());
38209 RespondingNodeType-EndcConfigUpdate::= CHOICE {
38210 respond-eNB ProtocolIE-Container {{ENB-ENDCConfigUpdateAckIEs}},
38211 respond-en-gNB ProtocolIE-Container {{En-gNB-ENDCConfigUpdateAckIEs}},
38216 struct RespondingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
38218 static constexpr const char* name() {return "RespondingNodeType-EndcConfigUpdate";}
38219 using parent_t = asn::choice<2, 0, true>;
38220 index_type get_index() const {return index;}
38221 bool is_unknown() const {return index == 3;}
38222 void set_unknown() { set_index(3); }
38223 ~RespondingNodeType_EndcConfigUpdate() {clear();}
38224 struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>
38226 static constexpr const char* name() {return "respond_eNB_t";}
38227 using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>;
38230 struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>
38232 static constexpr const char* name() {return "respond_en_gNB_t";}
38233 using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>;
38238 switch(get_index())
38240 case 1: var.destroy<respond_eNB_t>(); break;
38241 case 2: var.destroy<respond_en_gNB_t>(); break;
38246 template<typename V> bool decode(size_t idx, V& v)
38251 case 1: set_index(1); return v(var.build<respond_eNB_t>());
38252 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
38257 template<typename V> bool encode(V& v) const
38259 switch(get_index())
38261 case 1: return v(var.as<respond_eNB_t>());
38262 case 2: return v(var.as<respond_en_gNB_t>());
38266 template<typename V> static inline void enumerate(V& v)
38268 v.template operator()<respond_eNB_t>(1);
38269 v.template operator()<respond_en_gNB_t>(2);
38272 respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
38273 respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
38274 respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
38275 respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
38277 void set_index(index_type i) {index = i; base::set();}
38280 char dummy1[sizeof(respond_eNB_t)];
38281 char dummy2[sizeof(respond_en_gNB_t)];
38284 asn::variant<sizeof(union_type)> var;
38285 index_type index {0};
38288 ENDCConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
38289 { ID id-RespondingNodeType-EndcConfigUpdate CRITICALITY reject TYPE RespondingNodeType-EndcConfigUpdate PRESENCE mandatory},
38294 struct ENDCConfigurationUpdateAcknowledge_IEs
38296 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38298 size_t get_index() const {return type;}
38299 bool is_unknown() const { return type == 2; }
38300 void clear() {type = 0;}
38301 void select_id_RespondingNodeType_EndcConfigUpdate() { set(id_RespondingNodeType_EndcConfigUpdate); type=1;}
38302 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38303 template<typename V> bool decode(V& v)
38306 if(!v(ref_nested())) return false;
38307 if(equal(id_RespondingNodeType_EndcConfigUpdate)) { type = 1; return true; }
38308 else { type = 2; return true;}
38312 template<typename V> bool encode(V& v) const
38314 return v(ref_nested());
38318 template<typename V> bool decode(size_t index, V& v)
38323 case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcConfigUpdate);} return false;
38324 case 2: type = 2; return v(ref_nested());
38325 ref_nested().clear();
38330 template<typename V> bool encode(size_t index, V& v) const
38332 if(index != type) {return false;} return v(ref_nested());
38339 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38341 size_t get_index() const {return type;}
38342 bool is_unknown() const { return type == 2; }
38343 void clear() {type = 0;}
38344 void select_id_RespondingNodeType_EndcConfigUpdate() { set(reject); type=1;}
38345 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38346 template<typename V> bool decode(V& v)
38349 if(!v(ref_nested())) return false;
38350 if(equal(reject)) { type = 1; return true; }
38351 else { type = 2; return true;}
38355 template<typename V> bool encode(V& v) const
38357 return v(ref_nested());
38361 template<typename V> bool decode(size_t index, V& v)
38366 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38367 case 2: type = 2; return v(ref_nested());
38368 ref_nested().clear();
38373 template<typename V> bool encode(size_t index, V& v) const
38375 if(index != type) {return false;} return v(ref_nested());
38382 struct Value_t : asn::typefield<true>
38384 ~Value_t() {clear();}
38385 size_t get_index() const {return type;}
38386 RespondingNodeType_EndcConfigUpdate& select_id_RespondingNodeType_EndcConfigUpdate() { return set<RespondingNodeType_EndcConfigUpdate>(1); }
38387 RespondingNodeType_EndcConfigUpdate const* get_id_RespondingNodeType_EndcConfigUpdate() const { return get<RespondingNodeType_EndcConfigUpdate>(1); }
38388 bool is_unknown() const { return type == 2; }
38393 case 1: var.destroy<RespondingNodeType_EndcConfigUpdate>(); break;
38395 type = 0; ref_nested().clear();
38397 template<typename V> static inline void enumerate(V& v)
38399 v.template operator()<RespondingNodeType_EndcConfigUpdate>(1);
38403 template<typename V> bool decode(size_t index, V& v)
38408 case 1: v(select_id_RespondingNodeType_EndcConfigUpdate()); return true;
38409 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38414 template<typename V> bool encode(size_t index, V& v) const
38416 if(index != type) return false;
38419 case 1: v(var.as<RespondingNodeType_EndcConfigUpdate>()); return true;
38425 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38426 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38429 char dummy1[sizeof(RespondingNodeType_EndcConfigUpdate)];
38432 asn::variant<sizeof(union_type)> var;
38436 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38438 size_t get_index() const {return type;}
38439 bool is_unknown() const { return type == 2; }
38440 void clear() {type = 0;}
38441 void select_id_RespondingNodeType_EndcConfigUpdate() { set(mandatory); type=1;}
38442 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38443 template<typename V> bool decode(V& v)
38446 if(!v(ref_nested())) return false;
38447 if(equal(mandatory)) { type = 1; return true; }
38448 else { type = 2; return true;}
38452 template<typename V> bool encode(V& v) const
38454 return v(ref_nested());
38458 template<typename V> bool decode(size_t index, V& v)
38463 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38464 case 2: type = 2; return v(ref_nested());
38465 ref_nested().clear();
38470 template<typename V> bool encode(size_t index, V& v) const
38472 if(index != type) {return false;} return v(ref_nested());
38482 ENDCConfigurationUpdateAcknowledge ::= SEQUENCE {
38483 protocolIEs ProtocolIE-Container {{ENDCConfigurationUpdateAcknowledge-IEs}},
38488 struct ENDCConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
38490 static constexpr const char* name() {return "ENDCConfigurationUpdateAcknowledge";}
38491 using parent_t = asn::sequence<1, 0, true, 0>;
38492 struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>
38494 static constexpr const char* name() {return "protocolIEs_t";}
38495 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>;
38498 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38499 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38500 template<typename V> void decode(V& v)
38505 template<typename V> void encode(V& v) const
38512 protocolIEs.clear();
38516 protocolIEs_t protocolIEs;
38520 ENDCConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
38521 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
38522 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional }|
38523 { ID id-TimeToWait CRITICALITY ignore TYPE TimeToWait PRESENCE optional },
38528 struct ENDCConfigurationUpdateFailure_IEs
38530 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38532 size_t get_index() const {return type;}
38533 bool is_unknown() const { return type == 4; }
38534 void clear() {type = 0;}
38535 void select_id_Cause() { set(id_Cause); type=1;}
38536 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
38537 void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
38538 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38539 template<typename V> bool decode(V& v)
38542 if(!v(ref_nested())) return false;
38543 if(equal(id_Cause)) { type = 1; return true; }
38544 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
38545 else if(equal(id_TimeToWait)) { type = 3; return true; }
38546 else { type = 4; return true;}
38550 template<typename V> bool encode(V& v) const
38552 return v(ref_nested());
38556 template<typename V> bool decode(size_t index, V& v)
38561 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
38562 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
38563 case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
38564 case 4: type = 4; return v(ref_nested());
38565 ref_nested().clear();
38570 template<typename V> bool encode(size_t index, V& v) const
38572 if(index != type) {return false;} return v(ref_nested());
38579 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38581 size_t get_index() const {return type;}
38582 bool is_unknown() const { return type == 4; }
38583 void clear() {type = 0;}
38584 void select_id_Cause() { set(ignore); type=1;}
38585 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
38586 void select_id_TimeToWait() { set(ignore); type=3;}
38587 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38588 template<typename V> bool decode(V& v)
38591 if(!v(ref_nested())) return false;
38592 if(equal(ignore)) { type = 1; return true; }
38593 else if(equal(ignore)) { type = 2; return true; }
38594 else if(equal(ignore)) { type = 3; return true; }
38595 else { type = 4; return true;}
38599 template<typename V> bool encode(V& v) const
38601 return v(ref_nested());
38605 template<typename V> bool decode(size_t index, V& v)
38610 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
38611 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
38612 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
38613 case 4: type = 4; return v(ref_nested());
38614 ref_nested().clear();
38619 template<typename V> bool encode(size_t index, V& v) const
38621 if(index != type) {return false;} return v(ref_nested());
38628 struct Value_t : asn::typefield<true>
38630 ~Value_t() {clear();}
38631 size_t get_index() const {return type;}
38632 Cause& select_id_Cause() { return set<Cause>(1); }
38633 Cause const* get_id_Cause() const { return get<Cause>(1); }
38634 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
38635 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
38636 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
38637 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
38638 bool is_unknown() const { return type == 4; }
38643 case 1: var.destroy<Cause>(); break;
38644 case 2: var.destroy<CriticalityDiagnostics>(); break;
38645 case 3: var.destroy<TimeToWait>(); break;
38647 type = 0; ref_nested().clear();
38649 template<typename V> static inline void enumerate(V& v)
38651 v.template operator()<Cause>(1);
38652 v.template operator()<CriticalityDiagnostics>(2);
38653 v.template operator()<TimeToWait>(3);
38657 template<typename V> bool decode(size_t index, V& v)
38662 case 1: v(select_id_Cause()); return true;
38663 case 2: v(select_id_CriticalityDiagnostics()); return true;
38664 case 3: v(select_id_TimeToWait()); return true;
38665 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
38670 template<typename V> bool encode(size_t index, V& v) const
38672 if(index != type) return false;
38675 case 1: v(var.as<Cause>()); return true;
38676 case 2: v(var.as<CriticalityDiagnostics>()); return true;
38677 case 3: v(var.as<TimeToWait>()); return true;
38683 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38684 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38687 char dummy1[sizeof(Cause)];
38688 char dummy2[sizeof(CriticalityDiagnostics)];
38689 char dummy3[sizeof(TimeToWait)];
38692 asn::variant<sizeof(union_type)> var;
38696 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38698 size_t get_index() const {return type;}
38699 bool is_unknown() const { return type == 4; }
38700 void clear() {type = 0;}
38701 void select_id_Cause() { set(mandatory); type=1;}
38702 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
38703 void select_id_TimeToWait() { set(optional); type=3;}
38704 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38705 template<typename V> bool decode(V& v)
38708 if(!v(ref_nested())) return false;
38709 if(equal(mandatory)) { type = 1; return true; }
38710 else if(equal(optional)) { type = 2; return true; }
38711 else if(equal(optional)) { type = 3; return true; }
38712 else { type = 4; return true;}
38716 template<typename V> bool encode(V& v) const
38718 return v(ref_nested());
38722 template<typename V> bool decode(size_t index, V& v)
38727 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38728 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
38729 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
38730 case 4: type = 4; return v(ref_nested());
38731 ref_nested().clear();
38736 template<typename V> bool encode(size_t index, V& v) const
38738 if(index != type) {return false;} return v(ref_nested());
38748 ENDCConfigurationUpdateFailure ::= SEQUENCE {
38749 protocolIEs ProtocolIE-Container {{ENDCConfigurationUpdateFailure-IEs}},
38754 struct ENDCConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
38756 static constexpr const char* name() {return "ENDCConfigurationUpdateFailure";}
38757 using parent_t = asn::sequence<1, 0, true, 0>;
38758 struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>
38760 static constexpr const char* name() {return "protocolIEs_t";}
38761 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>;
38764 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38765 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38766 template<typename V> void decode(V& v)
38771 template<typename V> void encode(V& v) const
38778 protocolIEs.clear();
38782 protocolIEs_t protocolIEs;
38786 ENDCPartialResetConfirm-IEs X2AP-PROTOCOL-IES ::= {
38787 { ID id-UEs-Admitted-ToBeReset CRITICALITY reject TYPE UEsToBeResetList PRESENCE mandatory},
38792 struct ENDCPartialResetConfirm_IEs
38794 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38796 size_t get_index() const {return type;}
38797 bool is_unknown() const { return type == 2; }
38798 void clear() {type = 0;}
38799 void select_id_UEs_Admitted_ToBeReset() { set(id_UEs_Admitted_ToBeReset); type=1;}
38800 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38801 template<typename V> bool decode(V& v)
38804 if(!v(ref_nested())) return false;
38805 if(equal(id_UEs_Admitted_ToBeReset)) { type = 1; return true; }
38806 else { type = 2; return true;}
38810 template<typename V> bool encode(V& v) const
38812 return v(ref_nested());
38816 template<typename V> bool decode(size_t index, V& v)
38821 case 1: type = 1; if(v(ref_nested())) { return equal(id_UEs_Admitted_ToBeReset);} return false;
38822 case 2: type = 2; return v(ref_nested());
38823 ref_nested().clear();
38828 template<typename V> bool encode(size_t index, V& v) const
38830 if(index != type) {return false;} return v(ref_nested());
38837 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38839 size_t get_index() const {return type;}
38840 bool is_unknown() const { return type == 2; }
38841 void clear() {type = 0;}
38842 void select_id_UEs_Admitted_ToBeReset() { set(reject); type=1;}
38843 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38844 template<typename V> bool decode(V& v)
38847 if(!v(ref_nested())) return false;
38848 if(equal(reject)) { type = 1; return true; }
38849 else { type = 2; return true;}
38853 template<typename V> bool encode(V& v) const
38855 return v(ref_nested());
38859 template<typename V> bool decode(size_t index, V& v)
38864 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38865 case 2: type = 2; return v(ref_nested());
38866 ref_nested().clear();
38871 template<typename V> bool encode(size_t index, V& v) const
38873 if(index != type) {return false;} return v(ref_nested());
38880 struct Value_t : asn::typefield<true>
38882 ~Value_t() {clear();}
38883 size_t get_index() const {return type;}
38884 UEsToBeResetList& select_id_UEs_Admitted_ToBeReset() { return set<UEsToBeResetList>(1); }
38885 UEsToBeResetList const* get_id_UEs_Admitted_ToBeReset() const { return get<UEsToBeResetList>(1); }
38886 bool is_unknown() const { return type == 2; }
38891 case 1: var.destroy<UEsToBeResetList>(); break;
38893 type = 0; ref_nested().clear();
38895 template<typename V> static inline void enumerate(V& v)
38897 v.template operator()<UEsToBeResetList>(1);
38901 template<typename V> bool decode(size_t index, V& v)
38906 case 1: v(select_id_UEs_Admitted_ToBeReset()); return true;
38907 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38912 template<typename V> bool encode(size_t index, V& v) const
38914 if(index != type) return false;
38917 case 1: v(var.as<UEsToBeResetList>()); return true;
38923 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38924 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38927 char dummy1[sizeof(UEsToBeResetList)];
38930 asn::variant<sizeof(union_type)> var;
38934 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38936 size_t get_index() const {return type;}
38937 bool is_unknown() const { return type == 2; }
38938 void clear() {type = 0;}
38939 void select_id_UEs_Admitted_ToBeReset() { set(mandatory); type=1;}
38940 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38941 template<typename V> bool decode(V& v)
38944 if(!v(ref_nested())) return false;
38945 if(equal(mandatory)) { type = 1; return true; }
38946 else { type = 2; return true;}
38950 template<typename V> bool encode(V& v) const
38952 return v(ref_nested());
38956 template<typename V> bool decode(size_t index, V& v)
38961 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38962 case 2: type = 2; return v(ref_nested());
38963 ref_nested().clear();
38968 template<typename V> bool encode(size_t index, V& v) const
38970 if(index != type) {return false;} return v(ref_nested());
38980 ENDCPartialResetConfirm ::= SEQUENCE {
38981 protocolIEs ProtocolIE-Container {{ENDCPartialResetConfirm-IEs}},
38986 struct ENDCPartialResetConfirm : asn::sequence<1, 0, true, 0>
38988 static constexpr const char* name() {return "ENDCPartialResetConfirm";}
38989 using parent_t = asn::sequence<1, 0, true, 0>;
38990 struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetConfirm_IEs>
38992 static constexpr const char* name() {return "protocolIEs_t";}
38993 using parent_t = ProtocolIE_Container<ENDCPartialResetConfirm_IEs>;
38996 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38997 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38998 template<typename V> void decode(V& v)
39003 template<typename V> void encode(V& v) const
39010 protocolIEs.clear();
39014 protocolIEs_t protocolIEs;
39018 ENDCPartialResetRequired-IEs X2AP-PROTOCOL-IES ::= {
39019 { ID id-UEs-ToBeReset CRITICALITY reject TYPE UEsToBeResetList PRESENCE mandatory}|
39020 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory },
39025 struct ENDCPartialResetRequired_IEs
39027 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39029 size_t get_index() const {return type;}
39030 bool is_unknown() const { return type == 3; }
39031 void clear() {type = 0;}
39032 void select_id_UEs_ToBeReset() { set(id_UEs_ToBeReset); type=1;}
39033 void select_id_Cause() { set(id_Cause); type=2;}
39034 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39035 template<typename V> bool decode(V& v)
39038 if(!v(ref_nested())) return false;
39039 if(equal(id_UEs_ToBeReset)) { type = 1; return true; }
39040 else if(equal(id_Cause)) { type = 2; return true; }
39041 else { type = 3; return true;}
39045 template<typename V> bool encode(V& v) const
39047 return v(ref_nested());
39051 template<typename V> bool decode(size_t index, V& v)
39056 case 1: type = 1; if(v(ref_nested())) { return equal(id_UEs_ToBeReset);} return false;
39057 case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
39058 case 3: type = 3; return v(ref_nested());
39059 ref_nested().clear();
39064 template<typename V> bool encode(size_t index, V& v) const
39066 if(index != type) {return false;} return v(ref_nested());
39073 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39075 size_t get_index() const {return type;}
39076 bool is_unknown() const { return type == 3; }
39077 void clear() {type = 0;}
39078 void select_id_UEs_ToBeReset() { set(reject); type=1;}
39079 void select_id_Cause() { set(ignore); type=2;}
39080 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39081 template<typename V> bool decode(V& v)
39084 if(!v(ref_nested())) return false;
39085 if(equal(reject)) { type = 1; return true; }
39086 else if(equal(ignore)) { type = 2; return true; }
39087 else { type = 3; return true;}
39091 template<typename V> bool encode(V& v) const
39093 return v(ref_nested());
39097 template<typename V> bool decode(size_t index, V& v)
39102 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39103 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
39104 case 3: type = 3; return v(ref_nested());
39105 ref_nested().clear();
39110 template<typename V> bool encode(size_t index, V& v) const
39112 if(index != type) {return false;} return v(ref_nested());
39119 struct Value_t : asn::typefield<true>
39121 ~Value_t() {clear();}
39122 size_t get_index() const {return type;}
39123 UEsToBeResetList& select_id_UEs_ToBeReset() { return set<UEsToBeResetList>(1); }
39124 UEsToBeResetList const* get_id_UEs_ToBeReset() const { return get<UEsToBeResetList>(1); }
39125 Cause& select_id_Cause() { return set<Cause>(2); }
39126 Cause const* get_id_Cause() const { return get<Cause>(2); }
39127 bool is_unknown() const { return type == 3; }
39132 case 1: var.destroy<UEsToBeResetList>(); break;
39133 case 2: var.destroy<Cause>(); break;
39135 type = 0; ref_nested().clear();
39137 template<typename V> static inline void enumerate(V& v)
39139 v.template operator()<UEsToBeResetList>(1);
39140 v.template operator()<Cause>(2);
39144 template<typename V> bool decode(size_t index, V& v)
39149 case 1: v(select_id_UEs_ToBeReset()); return true;
39150 case 2: v(select_id_Cause()); return true;
39151 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
39156 template<typename V> bool encode(size_t index, V& v) const
39158 if(index != type) return false;
39161 case 1: v(var.as<UEsToBeResetList>()); return true;
39162 case 2: v(var.as<Cause>()); return true;
39168 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39169 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39172 char dummy1[sizeof(Cause)];
39173 char dummy2[sizeof(UEsToBeResetList)];
39176 asn::variant<sizeof(union_type)> var;
39180 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39182 size_t get_index() const {return type;}
39183 bool is_unknown() const { return type == 3; }
39184 void clear() {type = 0;}
39185 void select_id_UEs_ToBeReset() { set(mandatory); type=1;}
39186 void select_id_Cause() { set(mandatory); type=2;}
39187 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39188 template<typename V> bool decode(V& v)
39191 if(!v(ref_nested())) return false;
39192 if(equal(mandatory)) { type = 1; return true; }
39193 else if(equal(mandatory)) { type = 2; return true; }
39194 else { type = 3; return true;}
39198 template<typename V> bool encode(V& v) const
39200 return v(ref_nested());
39204 template<typename V> bool decode(size_t index, V& v)
39209 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39210 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
39211 case 3: type = 3; return v(ref_nested());
39212 ref_nested().clear();
39217 template<typename V> bool encode(size_t index, V& v) const
39219 if(index != type) {return false;} return v(ref_nested());
39229 ENDCPartialResetRequired ::= SEQUENCE {
39230 protocolIEs ProtocolIE-Container {{ENDCPartialResetRequired-IEs}},
39235 struct ENDCPartialResetRequired : asn::sequence<1, 0, true, 0>
39237 static constexpr const char* name() {return "ENDCPartialResetRequired";}
39238 using parent_t = asn::sequence<1, 0, true, 0>;
39239 struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetRequired_IEs>
39241 static constexpr const char* name() {return "protocolIEs_t";}
39242 using parent_t = ProtocolIE_Container<ENDCPartialResetRequired_IEs>;
39245 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
39246 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
39247 template<typename V> void decode(V& v)
39252 template<typename V> void encode(V& v) const
39259 protocolIEs.clear();
39263 protocolIEs_t protocolIEs;
39267 ENDCX2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
39268 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory} |
39269 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional },
39274 struct ENDCX2RemovalFailure_IEs
39276 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39278 size_t get_index() const {return type;}
39279 bool is_unknown() const { return type == 3; }
39280 void clear() {type = 0;}
39281 void select_id_Cause() { set(id_Cause); type=1;}
39282 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
39283 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39284 template<typename V> bool decode(V& v)
39287 if(!v(ref_nested())) return false;
39288 if(equal(id_Cause)) { type = 1; return true; }
39289 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
39290 else { type = 3; return true;}
39294 template<typename V> bool encode(V& v) const
39296 return v(ref_nested());
39300 template<typename V> bool decode(size_t index, V& v)
39305 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
39306 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
39307 case 3: type = 3; return v(ref_nested());
39308 ref_nested().clear();
39313 template<typename V> bool encode(size_t index, V& v) const
39315 if(index != type) {return false;} return v(ref_nested());
39322 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39324 size_t get_index() const {return type;}
39325 bool is_unknown() const { return type == 3; }
39326 void clear() {type = 0;}
39327 void select_id_Cause() { set(ignore); type=1;}
39328 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
39329 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39330 template<typename V> bool decode(V& v)
39333 if(!v(ref_nested())) return false;
39334 if(equal(ignore)) { type = 1; return true; }
39335 else if(equal(ignore)) { type = 2; return true; }
39336 else { type = 3; return true;}
39340 template<typename V> bool encode(V& v) const
39342 return v(ref_nested());
39346 template<typename V> bool decode(size_t index, V& v)
39351 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
39352 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
39353 case 3: type = 3; return v(ref_nested());
39354 ref_nested().clear();
39359 template<typename V> bool encode(size_t index, V& v) const
39361 if(index != type) {return false;} return v(ref_nested());
39368 struct Value_t : asn::typefield<true>
39370 ~Value_t() {clear();}
39371 size_t get_index() const {return type;}
39372 Cause& select_id_Cause() { return set<Cause>(1); }
39373 Cause const* get_id_Cause() const { return get<Cause>(1); }
39374 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
39375 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
39376 bool is_unknown() const { return type == 3; }
39381 case 1: var.destroy<Cause>(); break;
39382 case 2: var.destroy<CriticalityDiagnostics>(); break;
39384 type = 0; ref_nested().clear();
39386 template<typename V> static inline void enumerate(V& v)
39388 v.template operator()<Cause>(1);
39389 v.template operator()<CriticalityDiagnostics>(2);
39393 template<typename V> bool decode(size_t index, V& v)
39398 case 1: v(select_id_Cause()); return true;
39399 case 2: v(select_id_CriticalityDiagnostics()); return true;
39400 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
39405 template<typename V> bool encode(size_t index, V& v) const
39407 if(index != type) return false;
39410 case 1: v(var.as<Cause>()); return true;
39411 case 2: v(var.as<CriticalityDiagnostics>()); return true;
39417 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39418 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39421 char dummy1[sizeof(Cause)];
39422 char dummy2[sizeof(CriticalityDiagnostics)];
39425 asn::variant<sizeof(union_type)> var;
39429 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39431 size_t get_index() const {return type;}
39432 bool is_unknown() const { return type == 3; }
39433 void clear() {type = 0;}
39434 void select_id_Cause() { set(mandatory); type=1;}
39435 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
39436 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39437 template<typename V> bool decode(V& v)
39440 if(!v(ref_nested())) return false;
39441 if(equal(mandatory)) { type = 1; return true; }
39442 else if(equal(optional)) { type = 2; return true; }
39443 else { type = 3; return true;}
39447 template<typename V> bool encode(V& v) const
39449 return v(ref_nested());
39453 template<typename V> bool decode(size_t index, V& v)
39458 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39459 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
39460 case 3: type = 3; return v(ref_nested());
39461 ref_nested().clear();
39466 template<typename V> bool encode(size_t index, V& v) const
39468 if(index != type) {return false;} return v(ref_nested());
39478 ENDCX2RemovalFailure ::= SEQUENCE {
39479 protocolIEs ProtocolIE-Container {{ENDCX2RemovalFailure-IEs}},
39484 struct ENDCX2RemovalFailure : asn::sequence<1, 0, true, 0>
39486 static constexpr const char* name() {return "ENDCX2RemovalFailure";}
39487 using parent_t = asn::sequence<1, 0, true, 0>;
39488 struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalFailure_IEs>
39490 static constexpr const char* name() {return "protocolIEs_t";}
39491 using parent_t = ProtocolIE_Container<ENDCX2RemovalFailure_IEs>;
39494 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
39495 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
39496 template<typename V> void decode(V& v)
39501 template<typename V> void encode(V& v) const
39508 protocolIEs.clear();
39512 protocolIEs_t protocolIEs;
39516 En-gNB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
39517 { ID id-Globalen-gNB-ID CRITICALITY reject TYPE GlobalGNB-ID PRESENCE mandatory},
39522 struct En_gNB_ENDCX2RemovalReqIEs
39524 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39526 size_t get_index() const {return type;}
39527 bool is_unknown() const { return type == 2; }
39528 void clear() {type = 0;}
39529 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
39530 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39531 template<typename V> bool decode(V& v)
39534 if(!v(ref_nested())) return false;
39535 if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
39536 else { type = 2; return true;}
39540 template<typename V> bool encode(V& v) const
39542 return v(ref_nested());
39546 template<typename V> bool decode(size_t index, V& v)
39551 case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
39552 case 2: type = 2; return v(ref_nested());
39553 ref_nested().clear();
39558 template<typename V> bool encode(size_t index, V& v) const
39560 if(index != type) {return false;} return v(ref_nested());
39567 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39569 size_t get_index() const {return type;}
39570 bool is_unknown() const { return type == 2; }
39571 void clear() {type = 0;}
39572 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
39573 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39574 template<typename V> bool decode(V& v)
39577 if(!v(ref_nested())) return false;
39578 if(equal(reject)) { type = 1; return true; }
39579 else { type = 2; return true;}
39583 template<typename V> bool encode(V& v) const
39585 return v(ref_nested());
39589 template<typename V> bool decode(size_t index, V& v)
39594 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39595 case 2: type = 2; return v(ref_nested());
39596 ref_nested().clear();
39601 template<typename V> bool encode(size_t index, V& v) const
39603 if(index != type) {return false;} return v(ref_nested());
39610 struct Value_t : asn::typefield<true>
39612 ~Value_t() {clear();}
39613 size_t get_index() const {return type;}
39614 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
39615 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
39616 bool is_unknown() const { return type == 2; }
39621 case 1: var.destroy<GlobalGNB_ID>(); break;
39623 type = 0; ref_nested().clear();
39625 template<typename V> static inline void enumerate(V& v)
39627 v.template operator()<GlobalGNB_ID>(1);
39631 template<typename V> bool decode(size_t index, V& v)
39636 case 1: v(select_id_Globalen_gNB_ID()); return true;
39637 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
39642 template<typename V> bool encode(size_t index, V& v) const
39644 if(index != type) return false;
39647 case 1: v(var.as<GlobalGNB_ID>()); return true;
39653 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39654 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39657 char dummy1[sizeof(GlobalGNB_ID)];
39660 asn::variant<sizeof(union_type)> var;
39664 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39666 size_t get_index() const {return type;}
39667 bool is_unknown() const { return type == 2; }
39668 void clear() {type = 0;}
39669 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
39670 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39671 template<typename V> bool decode(V& v)
39674 if(!v(ref_nested())) return false;
39675 if(equal(mandatory)) { type = 1; return true; }
39676 else { type = 2; return true;}
39680 template<typename V> bool encode(V& v) const
39682 return v(ref_nested());
39686 template<typename V> bool decode(size_t index, V& v)
39691 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39692 case 2: type = 2; return v(ref_nested());
39693 ref_nested().clear();
39698 template<typename V> bool encode(size_t index, V& v) const
39700 if(index != type) {return false;} return v(ref_nested());
39710 InitiatingNodeType-EndcX2Removal ::= CHOICE {
39711 init-eNB ProtocolIE-Container {{ENB-ENDCX2RemovalReqIEs}},
39712 init-en-gNB ProtocolIE-Container {{En-gNB-ENDCX2RemovalReqIEs}},
39717 struct InitiatingNodeType_EndcX2Removal : asn::choice<2, 0, true>
39719 static constexpr const char* name() {return "InitiatingNodeType-EndcX2Removal";}
39720 using parent_t = asn::choice<2, 0, true>;
39721 index_type get_index() const {return index;}
39722 bool is_unknown() const {return index == 3;}
39723 void set_unknown() { set_index(3); }
39724 ~InitiatingNodeType_EndcX2Removal() {clear();}
39725 struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>
39727 static constexpr const char* name() {return "init_eNB_t";}
39728 using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>;
39731 struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>
39733 static constexpr const char* name() {return "init_en_gNB_t";}
39734 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>;
39739 switch(get_index())
39741 case 1: var.destroy<init_eNB_t>(); break;
39742 case 2: var.destroy<init_en_gNB_t>(); break;
39747 template<typename V> bool decode(size_t idx, V& v)
39752 case 1: set_index(1); return v(var.build<init_eNB_t>());
39753 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
39758 template<typename V> bool encode(V& v) const
39760 switch(get_index())
39762 case 1: return v(var.as<init_eNB_t>());
39763 case 2: return v(var.as<init_en_gNB_t>());
39767 template<typename V> static inline void enumerate(V& v)
39769 v.template operator()<init_eNB_t>(1);
39770 v.template operator()<init_en_gNB_t>(2);
39773 init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
39774 init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
39775 init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
39776 init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
39778 void set_index(index_type i) {index = i; base::set();}
39781 char dummy1[sizeof(init_eNB_t)];
39782 char dummy2[sizeof(init_en_gNB_t)];
39785 asn::variant<sizeof(union_type)> var;
39786 index_type index {0};
39789 ENDCX2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
39790 { ID id-InitiatingNodeType-EndcX2Removal CRITICALITY reject TYPE InitiatingNodeType-EndcX2Removal PRESENCE mandatory},
39795 struct ENDCX2RemovalRequest_IEs
39797 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39799 size_t get_index() const {return type;}
39800 bool is_unknown() const { return type == 2; }
39801 void clear() {type = 0;}
39802 void select_id_InitiatingNodeType_EndcX2Removal() { set(id_InitiatingNodeType_EndcX2Removal); type=1;}
39803 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39804 template<typename V> bool decode(V& v)
39807 if(!v(ref_nested())) return false;
39808 if(equal(id_InitiatingNodeType_EndcX2Removal)) { type = 1; return true; }
39809 else { type = 2; return true;}
39813 template<typename V> bool encode(V& v) const
39815 return v(ref_nested());
39819 template<typename V> bool decode(size_t index, V& v)
39824 case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcX2Removal);} return false;
39825 case 2: type = 2; return v(ref_nested());
39826 ref_nested().clear();
39831 template<typename V> bool encode(size_t index, V& v) const
39833 if(index != type) {return false;} return v(ref_nested());
39840 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39842 size_t get_index() const {return type;}
39843 bool is_unknown() const { return type == 2; }
39844 void clear() {type = 0;}
39845 void select_id_InitiatingNodeType_EndcX2Removal() { set(reject); type=1;}
39846 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39847 template<typename V> bool decode(V& v)
39850 if(!v(ref_nested())) return false;
39851 if(equal(reject)) { type = 1; return true; }
39852 else { type = 2; return true;}
39856 template<typename V> bool encode(V& v) const
39858 return v(ref_nested());
39862 template<typename V> bool decode(size_t index, V& v)
39867 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39868 case 2: type = 2; return v(ref_nested());
39869 ref_nested().clear();
39874 template<typename V> bool encode(size_t index, V& v) const
39876 if(index != type) {return false;} return v(ref_nested());
39883 struct Value_t : asn::typefield<true>
39885 ~Value_t() {clear();}
39886 size_t get_index() const {return type;}
39887 InitiatingNodeType_EndcX2Removal& select_id_InitiatingNodeType_EndcX2Removal() { return set<InitiatingNodeType_EndcX2Removal>(1); }
39888 InitiatingNodeType_EndcX2Removal const* get_id_InitiatingNodeType_EndcX2Removal() const { return get<InitiatingNodeType_EndcX2Removal>(1); }
39889 bool is_unknown() const { return type == 2; }
39894 case 1: var.destroy<InitiatingNodeType_EndcX2Removal>(); break;
39896 type = 0; ref_nested().clear();
39898 template<typename V> static inline void enumerate(V& v)
39900 v.template operator()<InitiatingNodeType_EndcX2Removal>(1);
39904 template<typename V> bool decode(size_t index, V& v)
39909 case 1: v(select_id_InitiatingNodeType_EndcX2Removal()); return true;
39910 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
39915 template<typename V> bool encode(size_t index, V& v) const
39917 if(index != type) return false;
39920 case 1: v(var.as<InitiatingNodeType_EndcX2Removal>()); return true;
39926 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39927 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39930 char dummy1[sizeof(InitiatingNodeType_EndcX2Removal)];
39933 asn::variant<sizeof(union_type)> var;
39937 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39939 size_t get_index() const {return type;}
39940 bool is_unknown() const { return type == 2; }
39941 void clear() {type = 0;}
39942 void select_id_InitiatingNodeType_EndcX2Removal() { set(mandatory); type=1;}
39943 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39944 template<typename V> bool decode(V& v)
39947 if(!v(ref_nested())) return false;
39948 if(equal(mandatory)) { type = 1; return true; }
39949 else { type = 2; return true;}
39953 template<typename V> bool encode(V& v) const
39955 return v(ref_nested());
39959 template<typename V> bool decode(size_t index, V& v)
39964 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39965 case 2: type = 2; return v(ref_nested());
39966 ref_nested().clear();
39971 template<typename V> bool encode(size_t index, V& v) const
39973 if(index != type) {return false;} return v(ref_nested());
39983 ENDCX2RemovalRequest ::= SEQUENCE {
39984 protocolIEs ProtocolIE-Container {{ENDCX2RemovalRequest-IEs}},
39989 struct ENDCX2RemovalRequest : asn::sequence<1, 0, true, 0>
39991 static constexpr const char* name() {return "ENDCX2RemovalRequest";}
39992 using parent_t = asn::sequence<1, 0, true, 0>;
39993 struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalRequest_IEs>
39995 static constexpr const char* name() {return "protocolIEs_t";}
39996 using parent_t = ProtocolIE_Container<ENDCX2RemovalRequest_IEs>;
39999 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40000 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40001 template<typename V> void decode(V& v)
40006 template<typename V> void encode(V& v) const
40013 protocolIEs.clear();
40017 protocolIEs_t protocolIEs;
40021 En-gNB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
40022 { ID id-Globalen-gNB-ID CRITICALITY reject TYPE GlobalGNB-ID PRESENCE mandatory},
40027 struct En_gNB_ENDCX2RemovalReqAckIEs
40029 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40031 size_t get_index() const {return type;}
40032 bool is_unknown() const { return type == 2; }
40033 void clear() {type = 0;}
40034 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
40035 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40036 template<typename V> bool decode(V& v)
40039 if(!v(ref_nested())) return false;
40040 if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
40041 else { type = 2; return true;}
40045 template<typename V> bool encode(V& v) const
40047 return v(ref_nested());
40051 template<typename V> bool decode(size_t index, V& v)
40056 case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
40057 case 2: type = 2; return v(ref_nested());
40058 ref_nested().clear();
40063 template<typename V> bool encode(size_t index, V& v) const
40065 if(index != type) {return false;} return v(ref_nested());
40072 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40074 size_t get_index() const {return type;}
40075 bool is_unknown() const { return type == 2; }
40076 void clear() {type = 0;}
40077 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
40078 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40079 template<typename V> bool decode(V& v)
40082 if(!v(ref_nested())) return false;
40083 if(equal(reject)) { type = 1; return true; }
40084 else { type = 2; return true;}
40088 template<typename V> bool encode(V& v) const
40090 return v(ref_nested());
40094 template<typename V> bool decode(size_t index, V& v)
40099 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40100 case 2: type = 2; return v(ref_nested());
40101 ref_nested().clear();
40106 template<typename V> bool encode(size_t index, V& v) const
40108 if(index != type) {return false;} return v(ref_nested());
40115 struct Value_t : asn::typefield<true>
40117 ~Value_t() {clear();}
40118 size_t get_index() const {return type;}
40119 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
40120 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
40121 bool is_unknown() const { return type == 2; }
40126 case 1: var.destroy<GlobalGNB_ID>(); break;
40128 type = 0; ref_nested().clear();
40130 template<typename V> static inline void enumerate(V& v)
40132 v.template operator()<GlobalGNB_ID>(1);
40136 template<typename V> bool decode(size_t index, V& v)
40141 case 1: v(select_id_Globalen_gNB_ID()); return true;
40142 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
40147 template<typename V> bool encode(size_t index, V& v) const
40149 if(index != type) return false;
40152 case 1: v(var.as<GlobalGNB_ID>()); return true;
40158 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40159 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40162 char dummy1[sizeof(GlobalGNB_ID)];
40165 asn::variant<sizeof(union_type)> var;
40169 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40171 size_t get_index() const {return type;}
40172 bool is_unknown() const { return type == 2; }
40173 void clear() {type = 0;}
40174 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
40175 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40176 template<typename V> bool decode(V& v)
40179 if(!v(ref_nested())) return false;
40180 if(equal(mandatory)) { type = 1; return true; }
40181 else { type = 2; return true;}
40185 template<typename V> bool encode(V& v) const
40187 return v(ref_nested());
40191 template<typename V> bool decode(size_t index, V& v)
40196 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40197 case 2: type = 2; return v(ref_nested());
40198 ref_nested().clear();
40203 template<typename V> bool encode(size_t index, V& v) const
40205 if(index != type) {return false;} return v(ref_nested());
40215 RespondingNodeType-EndcX2Removal ::= CHOICE {
40216 respond-eNB ProtocolIE-Container {{ENB-ENDCX2RemovalReqAckIEs}},
40217 respond-en-gNB ProtocolIE-Container {{En-gNB-ENDCX2RemovalReqAckIEs}},
40222 struct RespondingNodeType_EndcX2Removal : asn::choice<2, 0, true>
40224 static constexpr const char* name() {return "RespondingNodeType-EndcX2Removal";}
40225 using parent_t = asn::choice<2, 0, true>;
40226 index_type get_index() const {return index;}
40227 bool is_unknown() const {return index == 3;}
40228 void set_unknown() { set_index(3); }
40229 ~RespondingNodeType_EndcX2Removal() {clear();}
40230 struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>
40232 static constexpr const char* name() {return "respond_eNB_t";}
40233 using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>;
40236 struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>
40238 static constexpr const char* name() {return "respond_en_gNB_t";}
40239 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>;
40244 switch(get_index())
40246 case 1: var.destroy<respond_eNB_t>(); break;
40247 case 2: var.destroy<respond_en_gNB_t>(); break;
40252 template<typename V> bool decode(size_t idx, V& v)
40257 case 1: set_index(1); return v(var.build<respond_eNB_t>());
40258 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
40263 template<typename V> bool encode(V& v) const
40265 switch(get_index())
40267 case 1: return v(var.as<respond_eNB_t>());
40268 case 2: return v(var.as<respond_en_gNB_t>());
40272 template<typename V> static inline void enumerate(V& v)
40274 v.template operator()<respond_eNB_t>(1);
40275 v.template operator()<respond_en_gNB_t>(2);
40278 respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
40279 respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
40280 respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
40281 respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
40283 void set_index(index_type i) {index = i; base::set();}
40286 char dummy1[sizeof(respond_eNB_t)];
40287 char dummy2[sizeof(respond_en_gNB_t)];
40290 asn::variant<sizeof(union_type)> var;
40291 index_type index {0};
40294 ENDCX2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
40295 { ID id-RespondingNodeType-EndcX2Removal CRITICALITY reject TYPE RespondingNodeType-EndcX2Removal PRESENCE mandatory},
40300 struct ENDCX2RemovalResponse_IEs
40302 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40304 size_t get_index() const {return type;}
40305 bool is_unknown() const { return type == 2; }
40306 void clear() {type = 0;}
40307 void select_id_RespondingNodeType_EndcX2Removal() { set(id_RespondingNodeType_EndcX2Removal); type=1;}
40308 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40309 template<typename V> bool decode(V& v)
40312 if(!v(ref_nested())) return false;
40313 if(equal(id_RespondingNodeType_EndcX2Removal)) { type = 1; return true; }
40314 else { type = 2; return true;}
40318 template<typename V> bool encode(V& v) const
40320 return v(ref_nested());
40324 template<typename V> bool decode(size_t index, V& v)
40329 case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcX2Removal);} return false;
40330 case 2: type = 2; return v(ref_nested());
40331 ref_nested().clear();
40336 template<typename V> bool encode(size_t index, V& v) const
40338 if(index != type) {return false;} return v(ref_nested());
40345 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40347 size_t get_index() const {return type;}
40348 bool is_unknown() const { return type == 2; }
40349 void clear() {type = 0;}
40350 void select_id_RespondingNodeType_EndcX2Removal() { set(reject); type=1;}
40351 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40352 template<typename V> bool decode(V& v)
40355 if(!v(ref_nested())) return false;
40356 if(equal(reject)) { type = 1; return true; }
40357 else { type = 2; return true;}
40361 template<typename V> bool encode(V& v) const
40363 return v(ref_nested());
40367 template<typename V> bool decode(size_t index, V& v)
40372 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40373 case 2: type = 2; return v(ref_nested());
40374 ref_nested().clear();
40379 template<typename V> bool encode(size_t index, V& v) const
40381 if(index != type) {return false;} return v(ref_nested());
40388 struct Value_t : asn::typefield<true>
40390 ~Value_t() {clear();}
40391 size_t get_index() const {return type;}
40392 RespondingNodeType_EndcX2Removal& select_id_RespondingNodeType_EndcX2Removal() { return set<RespondingNodeType_EndcX2Removal>(1); }
40393 RespondingNodeType_EndcX2Removal const* get_id_RespondingNodeType_EndcX2Removal() const { return get<RespondingNodeType_EndcX2Removal>(1); }
40394 bool is_unknown() const { return type == 2; }
40399 case 1: var.destroy<RespondingNodeType_EndcX2Removal>(); break;
40401 type = 0; ref_nested().clear();
40403 template<typename V> static inline void enumerate(V& v)
40405 v.template operator()<RespondingNodeType_EndcX2Removal>(1);
40409 template<typename V> bool decode(size_t index, V& v)
40414 case 1: v(select_id_RespondingNodeType_EndcX2Removal()); return true;
40415 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
40420 template<typename V> bool encode(size_t index, V& v) const
40422 if(index != type) return false;
40425 case 1: v(var.as<RespondingNodeType_EndcX2Removal>()); return true;
40431 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40432 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40435 char dummy1[sizeof(RespondingNodeType_EndcX2Removal)];
40438 asn::variant<sizeof(union_type)> var;
40442 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40444 size_t get_index() const {return type;}
40445 bool is_unknown() const { return type == 2; }
40446 void clear() {type = 0;}
40447 void select_id_RespondingNodeType_EndcX2Removal() { set(mandatory); type=1;}
40448 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40449 template<typename V> bool decode(V& v)
40452 if(!v(ref_nested())) return false;
40453 if(equal(mandatory)) { type = 1; return true; }
40454 else { type = 2; return true;}
40458 template<typename V> bool encode(V& v) const
40460 return v(ref_nested());
40464 template<typename V> bool decode(size_t index, V& v)
40469 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40470 case 2: type = 2; return v(ref_nested());
40471 ref_nested().clear();
40476 template<typename V> bool encode(size_t index, V& v) const
40478 if(index != type) {return false;} return v(ref_nested());
40488 ENDCX2RemovalResponse ::= SEQUENCE {
40489 protocolIEs ProtocolIE-Container {{ENDCX2RemovalResponse-IEs}},
40494 struct ENDCX2RemovalResponse : asn::sequence<1, 0, true, 0>
40496 static constexpr const char* name() {return "ENDCX2RemovalResponse";}
40497 using parent_t = asn::sequence<1, 0, true, 0>;
40498 struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalResponse_IEs>
40500 static constexpr const char* name() {return "protocolIEs_t";}
40501 using parent_t = ProtocolIE_Container<ENDCX2RemovalResponse_IEs>;
40504 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40505 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40506 template<typename V> void decode(V& v)
40511 template<typename V> void encode(V& v) const
40518 protocolIEs.clear();
40522 protocolIEs_t protocolIEs;
40526 ENDCX2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
40527 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory} |
40528 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional } |
40529 { ID id-TimeToWait CRITICALITY ignore TYPE TimeToWait PRESENCE optional },
40534 struct ENDCX2SetupFailure_IEs
40536 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40538 size_t get_index() const {return type;}
40539 bool is_unknown() const { return type == 4; }
40540 void clear() {type = 0;}
40541 void select_id_Cause() { set(id_Cause); type=1;}
40542 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
40543 void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
40544 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40545 template<typename V> bool decode(V& v)
40548 if(!v(ref_nested())) return false;
40549 if(equal(id_Cause)) { type = 1; return true; }
40550 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
40551 else if(equal(id_TimeToWait)) { type = 3; return true; }
40552 else { type = 4; return true;}
40556 template<typename V> bool encode(V& v) const
40558 return v(ref_nested());
40562 template<typename V> bool decode(size_t index, V& v)
40567 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
40568 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
40569 case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
40570 case 4: type = 4; return v(ref_nested());
40571 ref_nested().clear();
40576 template<typename V> bool encode(size_t index, V& v) const
40578 if(index != type) {return false;} return v(ref_nested());
40585 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40587 size_t get_index() const {return type;}
40588 bool is_unknown() const { return type == 4; }
40589 void clear() {type = 0;}
40590 void select_id_Cause() { set(ignore); type=1;}
40591 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
40592 void select_id_TimeToWait() { set(ignore); type=3;}
40593 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40594 template<typename V> bool decode(V& v)
40597 if(!v(ref_nested())) return false;
40598 if(equal(ignore)) { type = 1; return true; }
40599 else if(equal(ignore)) { type = 2; return true; }
40600 else if(equal(ignore)) { type = 3; return true; }
40601 else { type = 4; return true;}
40605 template<typename V> bool encode(V& v) const
40607 return v(ref_nested());
40611 template<typename V> bool decode(size_t index, V& v)
40616 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
40617 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
40618 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
40619 case 4: type = 4; return v(ref_nested());
40620 ref_nested().clear();
40625 template<typename V> bool encode(size_t index, V& v) const
40627 if(index != type) {return false;} return v(ref_nested());
40634 struct Value_t : asn::typefield<true>
40636 ~Value_t() {clear();}
40637 size_t get_index() const {return type;}
40638 Cause& select_id_Cause() { return set<Cause>(1); }
40639 Cause const* get_id_Cause() const { return get<Cause>(1); }
40640 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
40641 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
40642 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
40643 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
40644 bool is_unknown() const { return type == 4; }
40649 case 1: var.destroy<Cause>(); break;
40650 case 2: var.destroy<CriticalityDiagnostics>(); break;
40651 case 3: var.destroy<TimeToWait>(); break;
40653 type = 0; ref_nested().clear();
40655 template<typename V> static inline void enumerate(V& v)
40657 v.template operator()<Cause>(1);
40658 v.template operator()<CriticalityDiagnostics>(2);
40659 v.template operator()<TimeToWait>(3);
40663 template<typename V> bool decode(size_t index, V& v)
40668 case 1: v(select_id_Cause()); return true;
40669 case 2: v(select_id_CriticalityDiagnostics()); return true;
40670 case 3: v(select_id_TimeToWait()); return true;
40671 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
40676 template<typename V> bool encode(size_t index, V& v) const
40678 if(index != type) return false;
40681 case 1: v(var.as<Cause>()); return true;
40682 case 2: v(var.as<CriticalityDiagnostics>()); return true;
40683 case 3: v(var.as<TimeToWait>()); return true;
40689 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40690 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40693 char dummy1[sizeof(Cause)];
40694 char dummy2[sizeof(CriticalityDiagnostics)];
40695 char dummy3[sizeof(TimeToWait)];
40698 asn::variant<sizeof(union_type)> var;
40702 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40704 size_t get_index() const {return type;}
40705 bool is_unknown() const { return type == 4; }
40706 void clear() {type = 0;}
40707 void select_id_Cause() { set(mandatory); type=1;}
40708 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
40709 void select_id_TimeToWait() { set(optional); type=3;}
40710 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40711 template<typename V> bool decode(V& v)
40714 if(!v(ref_nested())) return false;
40715 if(equal(mandatory)) { type = 1; return true; }
40716 else if(equal(optional)) { type = 2; return true; }
40717 else if(equal(optional)) { type = 3; return true; }
40718 else { type = 4; return true;}
40722 template<typename V> bool encode(V& v) const
40724 return v(ref_nested());
40728 template<typename V> bool decode(size_t index, V& v)
40733 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40734 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
40735 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
40736 case 4: type = 4; return v(ref_nested());
40737 ref_nested().clear();
40742 template<typename V> bool encode(size_t index, V& v) const
40744 if(index != type) {return false;} return v(ref_nested());
40754 ENDCX2SetupFailure ::= SEQUENCE {
40755 protocolIEs ProtocolIE-Container {{ENDCX2SetupFailure-IEs}},
40760 struct ENDCX2SetupFailure : asn::sequence<1, 0, true, 0>
40762 static constexpr const char* name() {return "ENDCX2SetupFailure";}
40763 using parent_t = asn::sequence<1, 0, true, 0>;
40764 struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupFailure_IEs>
40766 static constexpr const char* name() {return "protocolIEs_t";}
40767 using parent_t = ProtocolIE_Container<ENDCX2SetupFailure_IEs>;
40770 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40771 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40772 template<typename V> void decode(V& v)
40777 template<typename V> void encode(V& v) const
40784 protocolIEs.clear();
40788 protocolIEs_t protocolIEs;
40792 En-gNB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
40793 { ID id-Globalen-gNB-ID CRITICALITY reject TYPE GlobalGNB-ID PRESENCE mandatory}|
40794 { ID id-ServedNRcellsENDCX2ManagementList CRITICALITY reject TYPE ServedNRcellsENDCX2ManagementList PRESENCE mandatory},
40799 struct En_gNB_ENDCX2SetupReqIEs
40801 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40803 size_t get_index() const {return type;}
40804 bool is_unknown() const { return type == 3; }
40805 void clear() {type = 0;}
40806 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
40807 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
40808 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40809 template<typename V> bool decode(V& v)
40812 if(!v(ref_nested())) return false;
40813 if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
40814 else if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 2; return true; }
40815 else { type = 3; return true;}
40819 template<typename V> bool encode(V& v) const
40821 return v(ref_nested());
40825 template<typename V> bool decode(size_t index, V& v)
40830 case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
40831 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
40832 case 3: type = 3; return v(ref_nested());
40833 ref_nested().clear();
40838 template<typename V> bool encode(size_t index, V& v) const
40840 if(index != type) {return false;} return v(ref_nested());
40847 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40849 size_t get_index() const {return type;}
40850 bool is_unknown() const { return type == 3; }
40851 void clear() {type = 0;}
40852 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
40853 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
40854 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40855 template<typename V> bool decode(V& v)
40858 if(!v(ref_nested())) return false;
40859 if(equal(reject)) { type = 1; return true; }
40860 else if(equal(reject)) { type = 2; return true; }
40861 else { type = 3; return true;}
40865 template<typename V> bool encode(V& v) const
40867 return v(ref_nested());
40871 template<typename V> bool decode(size_t index, V& v)
40876 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40877 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
40878 case 3: type = 3; return v(ref_nested());
40879 ref_nested().clear();
40884 template<typename V> bool encode(size_t index, V& v) const
40886 if(index != type) {return false;} return v(ref_nested());
40893 struct Value_t : asn::typefield<true>
40895 ~Value_t() {clear();}
40896 size_t get_index() const {return type;}
40897 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
40898 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
40899 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
40900 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
40901 bool is_unknown() const { return type == 3; }
40906 case 1: var.destroy<GlobalGNB_ID>(); break;
40907 case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
40909 type = 0; ref_nested().clear();
40911 template<typename V> static inline void enumerate(V& v)
40913 v.template operator()<GlobalGNB_ID>(1);
40914 v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
40918 template<typename V> bool decode(size_t index, V& v)
40923 case 1: v(select_id_Globalen_gNB_ID()); return true;
40924 case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
40925 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
40930 template<typename V> bool encode(size_t index, V& v) const
40932 if(index != type) return false;
40935 case 1: v(var.as<GlobalGNB_ID>()); return true;
40936 case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
40942 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40943 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40946 char dummy1[sizeof(GlobalGNB_ID)];
40947 char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
40950 asn::variant<sizeof(union_type)> var;
40954 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40956 size_t get_index() const {return type;}
40957 bool is_unknown() const { return type == 3; }
40958 void clear() {type = 0;}
40959 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
40960 void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
40961 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40962 template<typename V> bool decode(V& v)
40965 if(!v(ref_nested())) return false;
40966 if(equal(mandatory)) { type = 1; return true; }
40967 else if(equal(mandatory)) { type = 2; return true; }
40968 else { type = 3; return true;}
40972 template<typename V> bool encode(V& v) const
40974 return v(ref_nested());
40978 template<typename V> bool decode(size_t index, V& v)
40983 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40984 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
40985 case 3: type = 3; return v(ref_nested());
40986 ref_nested().clear();
40991 template<typename V> bool encode(size_t index, V& v) const
40993 if(index != type) {return false;} return v(ref_nested());
41003 InitiatingNodeType-EndcX2Setup ::= CHOICE {
41004 init-eNB ProtocolIE-Container {{ENB-ENDCX2SetupReqIEs}},
41005 init-en-gNB ProtocolIE-Container {{En-gNB-ENDCX2SetupReqIEs}},
41010 struct InitiatingNodeType_EndcX2Setup : asn::choice<2, 0, true>
41012 static constexpr const char* name() {return "InitiatingNodeType-EndcX2Setup";}
41013 using parent_t = asn::choice<2, 0, true>;
41014 index_type get_index() const {return index;}
41015 bool is_unknown() const {return index == 3;}
41016 void set_unknown() { set_index(3); }
41017 ~InitiatingNodeType_EndcX2Setup() {clear();}
41018 struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>
41020 static constexpr const char* name() {return "init_eNB_t";}
41021 using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>;
41024 struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>
41026 static constexpr const char* name() {return "init_en_gNB_t";}
41027 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>;
41032 switch(get_index())
41034 case 1: var.destroy<init_eNB_t>(); break;
41035 case 2: var.destroy<init_en_gNB_t>(); break;
41040 template<typename V> bool decode(size_t idx, V& v)
41045 case 1: set_index(1); return v(var.build<init_eNB_t>());
41046 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
41051 template<typename V> bool encode(V& v) const
41053 switch(get_index())
41055 case 1: return v(var.as<init_eNB_t>());
41056 case 2: return v(var.as<init_en_gNB_t>());
41060 template<typename V> static inline void enumerate(V& v)
41062 v.template operator()<init_eNB_t>(1);
41063 v.template operator()<init_en_gNB_t>(2);
41066 init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
41067 init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
41068 init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
41069 init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
41071 void set_index(index_type i) {index = i; base::set();}
41074 char dummy1[sizeof(init_eNB_t)];
41075 char dummy2[sizeof(init_en_gNB_t)];
41078 asn::variant<sizeof(union_type)> var;
41079 index_type index {0};
41082 ENDCX2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
41083 { ID id-InitiatingNodeType-EndcX2Setup CRITICALITY reject TYPE InitiatingNodeType-EndcX2Setup PRESENCE mandatory},
41088 struct ENDCX2SetupRequest_IEs
41090 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41092 size_t get_index() const {return type;}
41093 bool is_unknown() const { return type == 2; }
41094 void clear() {type = 0;}
41095 void select_id_InitiatingNodeType_EndcX2Setup() { set(id_InitiatingNodeType_EndcX2Setup); type=1;}
41096 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41097 template<typename V> bool decode(V& v)
41100 if(!v(ref_nested())) return false;
41101 if(equal(id_InitiatingNodeType_EndcX2Setup)) { type = 1; return true; }
41102 else { type = 2; return true;}
41106 template<typename V> bool encode(V& v) const
41108 return v(ref_nested());
41112 template<typename V> bool decode(size_t index, V& v)
41117 case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcX2Setup);} return false;
41118 case 2: type = 2; return v(ref_nested());
41119 ref_nested().clear();
41124 template<typename V> bool encode(size_t index, V& v) const
41126 if(index != type) {return false;} return v(ref_nested());
41133 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41135 size_t get_index() const {return type;}
41136 bool is_unknown() const { return type == 2; }
41137 void clear() {type = 0;}
41138 void select_id_InitiatingNodeType_EndcX2Setup() { set(reject); type=1;}
41139 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41140 template<typename V> bool decode(V& v)
41143 if(!v(ref_nested())) return false;
41144 if(equal(reject)) { type = 1; return true; }
41145 else { type = 2; return true;}
41149 template<typename V> bool encode(V& v) const
41151 return v(ref_nested());
41155 template<typename V> bool decode(size_t index, V& v)
41160 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41161 case 2: type = 2; return v(ref_nested());
41162 ref_nested().clear();
41167 template<typename V> bool encode(size_t index, V& v) const
41169 if(index != type) {return false;} return v(ref_nested());
41176 struct Value_t : asn::typefield<true>
41178 ~Value_t() {clear();}
41179 size_t get_index() const {return type;}
41180 InitiatingNodeType_EndcX2Setup& select_id_InitiatingNodeType_EndcX2Setup() { return set<InitiatingNodeType_EndcX2Setup>(1); }
41181 InitiatingNodeType_EndcX2Setup const* get_id_InitiatingNodeType_EndcX2Setup() const { return get<InitiatingNodeType_EndcX2Setup>(1); }
41182 bool is_unknown() const { return type == 2; }
41187 case 1: var.destroy<InitiatingNodeType_EndcX2Setup>(); break;
41189 type = 0; ref_nested().clear();
41191 template<typename V> static inline void enumerate(V& v)
41193 v.template operator()<InitiatingNodeType_EndcX2Setup>(1);
41197 template<typename V> bool decode(size_t index, V& v)
41202 case 1: v(select_id_InitiatingNodeType_EndcX2Setup()); return true;
41203 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
41208 template<typename V> bool encode(size_t index, V& v) const
41210 if(index != type) return false;
41213 case 1: v(var.as<InitiatingNodeType_EndcX2Setup>()); return true;
41219 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41220 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41223 char dummy1[sizeof(InitiatingNodeType_EndcX2Setup)];
41226 asn::variant<sizeof(union_type)> var;
41230 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41232 size_t get_index() const {return type;}
41233 bool is_unknown() const { return type == 2; }
41234 void clear() {type = 0;}
41235 void select_id_InitiatingNodeType_EndcX2Setup() { set(mandatory); type=1;}
41236 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41237 template<typename V> bool decode(V& v)
41240 if(!v(ref_nested())) return false;
41241 if(equal(mandatory)) { type = 1; return true; }
41242 else { type = 2; return true;}
41246 template<typename V> bool encode(V& v) const
41248 return v(ref_nested());
41252 template<typename V> bool decode(size_t index, V& v)
41257 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41258 case 2: type = 2; return v(ref_nested());
41259 ref_nested().clear();
41264 template<typename V> bool encode(size_t index, V& v) const
41266 if(index != type) {return false;} return v(ref_nested());
41276 ENDCX2SetupRequest ::= SEQUENCE {
41277 protocolIEs ProtocolIE-Container {{ENDCX2SetupRequest-IEs}},
41282 struct ENDCX2SetupRequest : asn::sequence<1, 0, true, 0>
41284 static constexpr const char* name() {return "ENDCX2SetupRequest";}
41285 using parent_t = asn::sequence<1, 0, true, 0>;
41286 struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupRequest_IEs>
41288 static constexpr const char* name() {return "protocolIEs_t";}
41289 using parent_t = ProtocolIE_Container<ENDCX2SetupRequest_IEs>;
41292 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
41293 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
41294 template<typename V> void decode(V& v)
41299 template<typename V> void encode(V& v) const
41306 protocolIEs.clear();
41310 protocolIEs_t protocolIEs;
41314 En-gNB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
41315 { ID id-Globalen-gNB-ID CRITICALITY reject TYPE GlobalGNB-ID PRESENCE mandatory}|
41316 { ID id-ServedNRcellsENDCX2ManagementList CRITICALITY reject TYPE ServedNRcellsENDCX2ManagementList PRESENCE mandatory},
41321 struct En_gNB_ENDCX2SetupReqAckIEs
41323 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41325 size_t get_index() const {return type;}
41326 bool is_unknown() const { return type == 3; }
41327 void clear() {type = 0;}
41328 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
41329 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
41330 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41331 template<typename V> bool decode(V& v)
41334 if(!v(ref_nested())) return false;
41335 if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
41336 else if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 2; return true; }
41337 else { type = 3; return true;}
41341 template<typename V> bool encode(V& v) const
41343 return v(ref_nested());
41347 template<typename V> bool decode(size_t index, V& v)
41352 case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
41353 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
41354 case 3: type = 3; return v(ref_nested());
41355 ref_nested().clear();
41360 template<typename V> bool encode(size_t index, V& v) const
41362 if(index != type) {return false;} return v(ref_nested());
41369 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41371 size_t get_index() const {return type;}
41372 bool is_unknown() const { return type == 3; }
41373 void clear() {type = 0;}
41374 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
41375 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
41376 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41377 template<typename V> bool decode(V& v)
41380 if(!v(ref_nested())) return false;
41381 if(equal(reject)) { type = 1; return true; }
41382 else if(equal(reject)) { type = 2; return true; }
41383 else { type = 3; return true;}
41387 template<typename V> bool encode(V& v) const
41389 return v(ref_nested());
41393 template<typename V> bool decode(size_t index, V& v)
41398 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41399 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
41400 case 3: type = 3; return v(ref_nested());
41401 ref_nested().clear();
41406 template<typename V> bool encode(size_t index, V& v) const
41408 if(index != type) {return false;} return v(ref_nested());
41415 struct Value_t : asn::typefield<true>
41417 ~Value_t() {clear();}
41418 size_t get_index() const {return type;}
41419 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
41420 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
41421 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
41422 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
41423 bool is_unknown() const { return type == 3; }
41428 case 1: var.destroy<GlobalGNB_ID>(); break;
41429 case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
41431 type = 0; ref_nested().clear();
41433 template<typename V> static inline void enumerate(V& v)
41435 v.template operator()<GlobalGNB_ID>(1);
41436 v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
41440 template<typename V> bool decode(size_t index, V& v)
41445 case 1: v(select_id_Globalen_gNB_ID()); return true;
41446 case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
41447 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
41452 template<typename V> bool encode(size_t index, V& v) const
41454 if(index != type) return false;
41457 case 1: v(var.as<GlobalGNB_ID>()); return true;
41458 case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
41464 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41465 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41468 char dummy1[sizeof(GlobalGNB_ID)];
41469 char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
41472 asn::variant<sizeof(union_type)> var;
41476 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41478 size_t get_index() const {return type;}
41479 bool is_unknown() const { return type == 3; }
41480 void clear() {type = 0;}
41481 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
41482 void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
41483 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41484 template<typename V> bool decode(V& v)
41487 if(!v(ref_nested())) return false;
41488 if(equal(mandatory)) { type = 1; return true; }
41489 else if(equal(mandatory)) { type = 2; return true; }
41490 else { type = 3; return true;}
41494 template<typename V> bool encode(V& v) const
41496 return v(ref_nested());
41500 template<typename V> bool decode(size_t index, V& v)
41505 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41506 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
41507 case 3: type = 3; return v(ref_nested());
41508 ref_nested().clear();
41513 template<typename V> bool encode(size_t index, V& v) const
41515 if(index != type) {return false;} return v(ref_nested());
41525 RespondingNodeType-EndcX2Setup ::= CHOICE {
41526 respond-eNB ProtocolIE-Container {{ENB-ENDCX2SetupReqAckIEs}},
41527 respond-en-gNB ProtocolIE-Container {{En-gNB-ENDCX2SetupReqAckIEs}},
41532 struct RespondingNodeType_EndcX2Setup : asn::choice<2, 0, true>
41534 static constexpr const char* name() {return "RespondingNodeType-EndcX2Setup";}
41535 using parent_t = asn::choice<2, 0, true>;
41536 index_type get_index() const {return index;}
41537 bool is_unknown() const {return index == 3;}
41538 void set_unknown() { set_index(3); }
41539 ~RespondingNodeType_EndcX2Setup() {clear();}
41540 struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>
41542 static constexpr const char* name() {return "respond_eNB_t";}
41543 using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>;
41546 struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>
41548 static constexpr const char* name() {return "respond_en_gNB_t";}
41549 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>;
41554 switch(get_index())
41556 case 1: var.destroy<respond_eNB_t>(); break;
41557 case 2: var.destroy<respond_en_gNB_t>(); break;
41562 template<typename V> bool decode(size_t idx, V& v)
41567 case 1: set_index(1); return v(var.build<respond_eNB_t>());
41568 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
41573 template<typename V> bool encode(V& v) const
41575 switch(get_index())
41577 case 1: return v(var.as<respond_eNB_t>());
41578 case 2: return v(var.as<respond_en_gNB_t>());
41582 template<typename V> static inline void enumerate(V& v)
41584 v.template operator()<respond_eNB_t>(1);
41585 v.template operator()<respond_en_gNB_t>(2);
41588 respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
41589 respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
41590 respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
41591 respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
41593 void set_index(index_type i) {index = i; base::set();}
41596 char dummy1[sizeof(respond_eNB_t)];
41597 char dummy2[sizeof(respond_en_gNB_t)];
41600 asn::variant<sizeof(union_type)> var;
41601 index_type index {0};
41604 ENDCX2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
41605 { ID id-RespondingNodeType-EndcX2Setup CRITICALITY reject TYPE RespondingNodeType-EndcX2Setup PRESENCE mandatory},
41610 struct ENDCX2SetupResponse_IEs
41612 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41614 size_t get_index() const {return type;}
41615 bool is_unknown() const { return type == 2; }
41616 void clear() {type = 0;}
41617 void select_id_RespondingNodeType_EndcX2Setup() { set(id_RespondingNodeType_EndcX2Setup); type=1;}
41618 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41619 template<typename V> bool decode(V& v)
41622 if(!v(ref_nested())) return false;
41623 if(equal(id_RespondingNodeType_EndcX2Setup)) { type = 1; return true; }
41624 else { type = 2; return true;}
41628 template<typename V> bool encode(V& v) const
41630 return v(ref_nested());
41634 template<typename V> bool decode(size_t index, V& v)
41639 case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcX2Setup);} return false;
41640 case 2: type = 2; return v(ref_nested());
41641 ref_nested().clear();
41646 template<typename V> bool encode(size_t index, V& v) const
41648 if(index != type) {return false;} return v(ref_nested());
41655 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41657 size_t get_index() const {return type;}
41658 bool is_unknown() const { return type == 2; }
41659 void clear() {type = 0;}
41660 void select_id_RespondingNodeType_EndcX2Setup() { set(reject); type=1;}
41661 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41662 template<typename V> bool decode(V& v)
41665 if(!v(ref_nested())) return false;
41666 if(equal(reject)) { type = 1; return true; }
41667 else { type = 2; return true;}
41671 template<typename V> bool encode(V& v) const
41673 return v(ref_nested());
41677 template<typename V> bool decode(size_t index, V& v)
41682 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41683 case 2: type = 2; return v(ref_nested());
41684 ref_nested().clear();
41689 template<typename V> bool encode(size_t index, V& v) const
41691 if(index != type) {return false;} return v(ref_nested());
41698 struct Value_t : asn::typefield<true>
41700 ~Value_t() {clear();}
41701 size_t get_index() const {return type;}
41702 RespondingNodeType_EndcX2Setup& select_id_RespondingNodeType_EndcX2Setup() { return set<RespondingNodeType_EndcX2Setup>(1); }
41703 RespondingNodeType_EndcX2Setup const* get_id_RespondingNodeType_EndcX2Setup() const { return get<RespondingNodeType_EndcX2Setup>(1); }
41704 bool is_unknown() const { return type == 2; }
41709 case 1: var.destroy<RespondingNodeType_EndcX2Setup>(); break;
41711 type = 0; ref_nested().clear();
41713 template<typename V> static inline void enumerate(V& v)
41715 v.template operator()<RespondingNodeType_EndcX2Setup>(1);
41719 template<typename V> bool decode(size_t index, V& v)
41724 case 1: v(select_id_RespondingNodeType_EndcX2Setup()); return true;
41725 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
41730 template<typename V> bool encode(size_t index, V& v) const
41732 if(index != type) return false;
41735 case 1: v(var.as<RespondingNodeType_EndcX2Setup>()); return true;
41741 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41742 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41745 char dummy1[sizeof(RespondingNodeType_EndcX2Setup)];
41748 asn::variant<sizeof(union_type)> var;
41752 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41754 size_t get_index() const {return type;}
41755 bool is_unknown() const { return type == 2; }
41756 void clear() {type = 0;}
41757 void select_id_RespondingNodeType_EndcX2Setup() { set(mandatory); type=1;}
41758 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41759 template<typename V> bool decode(V& v)
41762 if(!v(ref_nested())) return false;
41763 if(equal(mandatory)) { type = 1; return true; }
41764 else { type = 2; return true;}
41768 template<typename V> bool encode(V& v) const
41770 return v(ref_nested());
41774 template<typename V> bool decode(size_t index, V& v)
41779 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41780 case 2: type = 2; return v(ref_nested());
41781 ref_nested().clear();
41786 template<typename V> bool encode(size_t index, V& v) const
41788 if(index != type) {return false;} return v(ref_nested());
41798 ENDCX2SetupResponse ::= SEQUENCE {
41799 protocolIEs ProtocolIE-Container {{ENDCX2SetupResponse-IEs}},
41804 struct ENDCX2SetupResponse : asn::sequence<1, 0, true, 0>
41806 static constexpr const char* name() {return "ENDCX2SetupResponse";}
41807 using parent_t = asn::sequence<1, 0, true, 0>;
41808 struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupResponse_IEs>
41810 static constexpr const char* name() {return "protocolIEs_t";}
41811 using parent_t = ProtocolIE_Container<ENDCX2SetupResponse_IEs>;
41814 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
41815 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
41816 template<typename V> void decode(V& v)
41821 template<typename V> void encode(V& v) const
41828 protocolIEs.clear();
41832 protocolIEs_t protocolIEs;
41836 ListofEUTRACellsinNRCoordinationReq ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
41839 struct ListofEUTRACellsinNRCoordinationReq_elm : ECGI
41841 static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq_elm";}
41842 using parent_t = ECGI;
41845 struct ListofEUTRACellsinNRCoordinationReq : asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>
41847 static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq";}
41848 using parent_t = asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>;
41849 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
41853 ListofNRCellsinNRCoordinationReq ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
41856 struct ListofNRCellsinNRCoordinationReq_elm : NRCGI
41858 static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq_elm";}
41859 using parent_t = NRCGI;
41862 struct ListofNRCellsinNRCoordinationReq : asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>
41864 static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq";}
41865 using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>;
41866 using constraint_t = asn::constraints<false,asn::span<0, maxnoNRcellsSpectrumSharingWithE_UTRA >>;
41870 En-gNB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
41871 { ID id-DataTrafficResourceIndication CRITICALITY reject TYPE DataTrafficResourceIndication PRESENCE mandatory}|
41872 { ID id-ListofEUTRACellsinNRCoordinationReq CRITICALITY reject TYPE ListofEUTRACellsinNRCoordinationReq PRESENCE mandatory }|
41873 { ID id-SpectrumSharingGroupID CRITICALITY reject TYPE SpectrumSharingGroupID PRESENCE mandatory}|
41874 { ID id-ListofNRCellsinNRCoordinationReq CRITICALITY reject TYPE ListofNRCellsinNRCoordinationReq PRESENCE mandatory},
41879 struct En_gNB_EUTRA_NRCellResourceCoordinationReqIEs
41881 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41883 size_t get_index() const {return type;}
41884 bool is_unknown() const { return type == 5; }
41885 void clear() {type = 0;}
41886 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
41887 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(id_ListofEUTRACellsinNRCoordinationReq); type=2;}
41888 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=3;}
41889 void select_id_ListofNRCellsinNRCoordinationReq() { set(id_ListofNRCellsinNRCoordinationReq); type=4;}
41890 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41891 template<typename V> bool decode(V& v)
41894 if(!v(ref_nested())) return false;
41895 if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
41896 else if(equal(id_ListofEUTRACellsinNRCoordinationReq)) { type = 2; return true; }
41897 else if(equal(id_SpectrumSharingGroupID)) { type = 3; return true; }
41898 else if(equal(id_ListofNRCellsinNRCoordinationReq)) { type = 4; return true; }
41899 else { type = 5; return true;}
41903 template<typename V> bool encode(V& v) const
41905 return v(ref_nested());
41909 template<typename V> bool decode(size_t index, V& v)
41914 case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
41915 case 2: type = 2; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinNRCoordinationReq);} return false;
41916 case 3: type = 3; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
41917 case 4: type = 4; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationReq);} return false;
41918 case 5: type = 5; return v(ref_nested());
41919 ref_nested().clear();
41924 template<typename V> bool encode(size_t index, V& v) const
41926 if(index != type) {return false;} return v(ref_nested());
41933 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41935 size_t get_index() const {return type;}
41936 bool is_unknown() const { return type == 5; }
41937 void clear() {type = 0;}
41938 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
41939 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(reject); type=2;}
41940 void select_id_SpectrumSharingGroupID() { set(reject); type=3;}
41941 void select_id_ListofNRCellsinNRCoordinationReq() { set(reject); type=4;}
41942 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41943 template<typename V> bool decode(V& v)
41946 if(!v(ref_nested())) return false;
41947 if(equal(reject)) { type = 1; return true; }
41948 else if(equal(reject)) { type = 2; return true; }
41949 else if(equal(reject)) { type = 3; return true; }
41950 else if(equal(reject)) { type = 4; return true; }
41951 else { type = 5; return true;}
41955 template<typename V> bool encode(V& v) const
41957 return v(ref_nested());
41961 template<typename V> bool decode(size_t index, V& v)
41966 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41967 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
41968 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
41969 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
41970 case 5: type = 5; return v(ref_nested());
41971 ref_nested().clear();
41976 template<typename V> bool encode(size_t index, V& v) const
41978 if(index != type) {return false;} return v(ref_nested());
41985 struct Value_t : asn::typefield<true>
41987 ~Value_t() {clear();}
41988 size_t get_index() const {return type;}
41989 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
41990 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
41991 ListofEUTRACellsinNRCoordinationReq& select_id_ListofEUTRACellsinNRCoordinationReq() { return set<ListofEUTRACellsinNRCoordinationReq>(2); }
41992 ListofEUTRACellsinNRCoordinationReq const* get_id_ListofEUTRACellsinNRCoordinationReq() const { return get<ListofEUTRACellsinNRCoordinationReq>(2); }
41993 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(3); }
41994 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(3); }
41995 ListofNRCellsinNRCoordinationReq& select_id_ListofNRCellsinNRCoordinationReq() { return set<ListofNRCellsinNRCoordinationReq>(4); }
41996 ListofNRCellsinNRCoordinationReq const* get_id_ListofNRCellsinNRCoordinationReq() const { return get<ListofNRCellsinNRCoordinationReq>(4); }
41997 bool is_unknown() const { return type == 5; }
42002 case 1: var.destroy<DataTrafficResourceIndication>(); break;
42003 case 2: var.destroy<ListofEUTRACellsinNRCoordinationReq>(); break;
42004 case 3: var.destroy<SpectrumSharingGroupID>(); break;
42005 case 4: var.destroy<ListofNRCellsinNRCoordinationReq>(); break;
42007 type = 0; ref_nested().clear();
42009 template<typename V> static inline void enumerate(V& v)
42011 v.template operator()<DataTrafficResourceIndication>(1);
42012 v.template operator()<ListofEUTRACellsinNRCoordinationReq>(2);
42013 v.template operator()<SpectrumSharingGroupID>(3);
42014 v.template operator()<ListofNRCellsinNRCoordinationReq>(4);
42018 template<typename V> bool decode(size_t index, V& v)
42023 case 1: v(select_id_DataTrafficResourceIndication()); return true;
42024 case 2: v(select_id_ListofEUTRACellsinNRCoordinationReq()); return true;
42025 case 3: v(select_id_SpectrumSharingGroupID()); return true;
42026 case 4: v(select_id_ListofNRCellsinNRCoordinationReq()); return true;
42027 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
42032 template<typename V> bool encode(size_t index, V& v) const
42034 if(index != type) return false;
42037 case 1: v(var.as<DataTrafficResourceIndication>()); return true;
42038 case 2: v(var.as<ListofEUTRACellsinNRCoordinationReq>()); return true;
42039 case 3: v(var.as<SpectrumSharingGroupID>()); return true;
42040 case 4: v(var.as<ListofNRCellsinNRCoordinationReq>()); return true;
42046 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42047 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42050 char dummy1[sizeof(DataTrafficResourceIndication)];
42051 char dummy2[sizeof(ListofEUTRACellsinNRCoordinationReq)];
42052 char dummy3[sizeof(ListofNRCellsinNRCoordinationReq)];
42053 char dummy4[sizeof(SpectrumSharingGroupID)];
42056 asn::variant<sizeof(union_type)> var;
42060 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42062 size_t get_index() const {return type;}
42063 bool is_unknown() const { return type == 5; }
42064 void clear() {type = 0;}
42065 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
42066 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(mandatory); type=2;}
42067 void select_id_SpectrumSharingGroupID() { set(mandatory); type=3;}
42068 void select_id_ListofNRCellsinNRCoordinationReq() { set(mandatory); type=4;}
42069 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42070 template<typename V> bool decode(V& v)
42073 if(!v(ref_nested())) return false;
42074 if(equal(mandatory)) { type = 1; return true; }
42075 else if(equal(mandatory)) { type = 2; return true; }
42076 else if(equal(mandatory)) { type = 3; return true; }
42077 else if(equal(mandatory)) { type = 4; return true; }
42078 else { type = 5; return true;}
42082 template<typename V> bool encode(V& v) const
42084 return v(ref_nested());
42088 template<typename V> bool decode(size_t index, V& v)
42093 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42094 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
42095 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
42096 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
42097 case 5: type = 5; return v(ref_nested());
42098 ref_nested().clear();
42103 template<typename V> bool encode(size_t index, V& v) const
42105 if(index != type) {return false;} return v(ref_nested());
42115 InitiatingNodeType-EutranrCellResourceCoordination ::= CHOICE {
42116 initiate-eNB ProtocolIE-Container {{ENB-EUTRA-NRCellResourceCoordinationReqIEs}},
42117 initiate-en-gNB ProtocolIE-Container {{En-gNB-EUTRA-NRCellResourceCoordinationReqIEs}},
42122 struct InitiatingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
42124 static constexpr const char* name() {return "InitiatingNodeType-EutranrCellResourceCoordination";}
42125 using parent_t = asn::choice<2, 0, true>;
42126 index_type get_index() const {return index;}
42127 bool is_unknown() const {return index == 3;}
42128 void set_unknown() { set_index(3); }
42129 ~InitiatingNodeType_EutranrCellResourceCoordination() {clear();}
42130 struct initiate_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>
42132 static constexpr const char* name() {return "initiate_eNB_t";}
42133 using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>;
42136 struct initiate_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>
42138 static constexpr const char* name() {return "initiate_en_gNB_t";}
42139 using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>;
42144 switch(get_index())
42146 case 1: var.destroy<initiate_eNB_t>(); break;
42147 case 2: var.destroy<initiate_en_gNB_t>(); break;
42152 template<typename V> bool decode(size_t idx, V& v)
42157 case 1: set_index(1); return v(var.build<initiate_eNB_t>());
42158 case 2: set_index(2); return v(var.build<initiate_en_gNB_t>());
42163 template<typename V> bool encode(V& v) const
42165 switch(get_index())
42167 case 1: return v(var.as<initiate_eNB_t>());
42168 case 2: return v(var.as<initiate_en_gNB_t>());
42172 template<typename V> static inline void enumerate(V& v)
42174 v.template operator()<initiate_eNB_t>(1);
42175 v.template operator()<initiate_en_gNB_t>(2);
42178 initiate_eNB_t& select_initiate_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<initiate_eNB_t>();} return var.as<initiate_eNB_t>();}
42179 initiate_eNB_t const* get_initiate_eNB() const { if(get_index() == 1) { return &var.as<initiate_eNB_t>();} return nullptr; }
42180 initiate_en_gNB_t& select_initiate_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<initiate_en_gNB_t>();} return var.as<initiate_en_gNB_t>();}
42181 initiate_en_gNB_t const* get_initiate_en_gNB() const { if(get_index() == 2) { return &var.as<initiate_en_gNB_t>();} return nullptr; }
42183 void set_index(index_type i) {index = i; base::set();}
42186 char dummy1[sizeof(initiate_eNB_t)];
42187 char dummy2[sizeof(initiate_en_gNB_t)];
42190 asn::variant<sizeof(union_type)> var;
42191 index_type index {0};
42194 EUTRANRCellResourceCoordinationRequest-IEs X2AP-PROTOCOL-IES ::= {
42195 { ID id-InitiatingNodeType-EutranrCellResourceCoordination CRITICALITY reject TYPE InitiatingNodeType-EutranrCellResourceCoordination PRESENCE mandatory},
42200 struct EUTRANRCellResourceCoordinationRequest_IEs
42202 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42204 size_t get_index() const {return type;}
42205 bool is_unknown() const { return type == 2; }
42206 void clear() {type = 0;}
42207 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(id_InitiatingNodeType_EutranrCellResourceCoordination); type=1;}
42208 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42209 template<typename V> bool decode(V& v)
42212 if(!v(ref_nested())) return false;
42213 if(equal(id_InitiatingNodeType_EutranrCellResourceCoordination)) { type = 1; return true; }
42214 else { type = 2; return true;}
42218 template<typename V> bool encode(V& v) const
42220 return v(ref_nested());
42224 template<typename V> bool decode(size_t index, V& v)
42229 case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EutranrCellResourceCoordination);} return false;
42230 case 2: type = 2; return v(ref_nested());
42231 ref_nested().clear();
42236 template<typename V> bool encode(size_t index, V& v) const
42238 if(index != type) {return false;} return v(ref_nested());
42245 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42247 size_t get_index() const {return type;}
42248 bool is_unknown() const { return type == 2; }
42249 void clear() {type = 0;}
42250 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(reject); type=1;}
42251 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42252 template<typename V> bool decode(V& v)
42255 if(!v(ref_nested())) return false;
42256 if(equal(reject)) { type = 1; return true; }
42257 else { type = 2; return true;}
42261 template<typename V> bool encode(V& v) const
42263 return v(ref_nested());
42267 template<typename V> bool decode(size_t index, V& v)
42272 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42273 case 2: type = 2; return v(ref_nested());
42274 ref_nested().clear();
42279 template<typename V> bool encode(size_t index, V& v) const
42281 if(index != type) {return false;} return v(ref_nested());
42288 struct Value_t : asn::typefield<true>
42290 ~Value_t() {clear();}
42291 size_t get_index() const {return type;}
42292 InitiatingNodeType_EutranrCellResourceCoordination& select_id_InitiatingNodeType_EutranrCellResourceCoordination() { return set<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
42293 InitiatingNodeType_EutranrCellResourceCoordination const* get_id_InitiatingNodeType_EutranrCellResourceCoordination() const { return get<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
42294 bool is_unknown() const { return type == 2; }
42299 case 1: var.destroy<InitiatingNodeType_EutranrCellResourceCoordination>(); break;
42301 type = 0; ref_nested().clear();
42303 template<typename V> static inline void enumerate(V& v)
42305 v.template operator()<InitiatingNodeType_EutranrCellResourceCoordination>(1);
42309 template<typename V> bool decode(size_t index, V& v)
42314 case 1: v(select_id_InitiatingNodeType_EutranrCellResourceCoordination()); return true;
42315 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
42320 template<typename V> bool encode(size_t index, V& v) const
42322 if(index != type) return false;
42325 case 1: v(var.as<InitiatingNodeType_EutranrCellResourceCoordination>()); return true;
42331 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42332 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42335 char dummy1[sizeof(InitiatingNodeType_EutranrCellResourceCoordination)];
42338 asn::variant<sizeof(union_type)> var;
42342 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42344 size_t get_index() const {return type;}
42345 bool is_unknown() const { return type == 2; }
42346 void clear() {type = 0;}
42347 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(mandatory); type=1;}
42348 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42349 template<typename V> bool decode(V& v)
42352 if(!v(ref_nested())) return false;
42353 if(equal(mandatory)) { type = 1; return true; }
42354 else { type = 2; return true;}
42358 template<typename V> bool encode(V& v) const
42360 return v(ref_nested());
42364 template<typename V> bool decode(size_t index, V& v)
42369 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42370 case 2: type = 2; return v(ref_nested());
42371 ref_nested().clear();
42376 template<typename V> bool encode(size_t index, V& v) const
42378 if(index != type) {return false;} return v(ref_nested());
42388 EUTRANRCellResourceCoordinationRequest ::= SEQUENCE {
42389 protocolIEs ProtocolIE-Container {{EUTRANRCellResourceCoordinationRequest-IEs}},
42394 struct EUTRANRCellResourceCoordinationRequest : asn::sequence<1, 0, true, 0>
42396 static constexpr const char* name() {return "EUTRANRCellResourceCoordinationRequest";}
42397 using parent_t = asn::sequence<1, 0, true, 0>;
42398 struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>
42400 static constexpr const char* name() {return "protocolIEs_t";}
42401 using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>;
42404 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
42405 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
42406 template<typename V> void decode(V& v)
42411 template<typename V> void encode(V& v) const
42418 protocolIEs.clear();
42422 protocolIEs_t protocolIEs;
42426 ListofNRCellsinNRCoordinationResp ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
42429 struct ListofNRCellsinNRCoordinationResp_elm : NRCGI
42431 static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp_elm";}
42432 using parent_t = NRCGI;
42435 struct ListofNRCellsinNRCoordinationResp : asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>
42437 static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp";}
42438 using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>;
42439 using constraint_t = asn::constraints<false,asn::span<0, maxnoNRcellsSpectrumSharingWithE_UTRA >>;
42443 En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
42444 { ID id-DataTrafficResourceIndication CRITICALITY reject TYPE DataTrafficResourceIndication PRESENCE mandatory}|
42445 { ID id-SpectrumSharingGroupID CRITICALITY reject TYPE SpectrumSharingGroupID PRESENCE mandatory}|
42446 { ID id-ListofNRCellsinNRCoordinationResp CRITICALITY reject TYPE ListofNRCellsinNRCoordinationResp PRESENCE mandatory},
42453 struct En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs
42455 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42457 size_t get_index() const {return type;}
42458 bool is_unknown() const { return type == 4; }
42459 void clear() {type = 0;}
42460 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
42461 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
42462 void select_id_ListofNRCellsinNRCoordinationResp() { set(id_ListofNRCellsinNRCoordinationResp); type=3;}
42463 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42464 template<typename V> bool decode(V& v)
42467 if(!v(ref_nested())) return false;
42468 if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
42469 else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
42470 else if(equal(id_ListofNRCellsinNRCoordinationResp)) { type = 3; return true; }
42471 else { type = 4; return true;}
42475 template<typename V> bool encode(V& v) const
42477 return v(ref_nested());
42481 template<typename V> bool decode(size_t index, V& v)
42486 case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
42487 case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
42488 case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationResp);} return false;
42489 case 4: type = 4; return v(ref_nested());
42490 ref_nested().clear();
42495 template<typename V> bool encode(size_t index, V& v) const
42497 if(index != type) {return false;} return v(ref_nested());
42504 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42506 size_t get_index() const {return type;}
42507 bool is_unknown() const { return type == 4; }
42508 void clear() {type = 0;}
42509 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
42510 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
42511 void select_id_ListofNRCellsinNRCoordinationResp() { set(reject); type=3;}
42512 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42513 template<typename V> bool decode(V& v)
42516 if(!v(ref_nested())) return false;
42517 if(equal(reject)) { type = 1; return true; }
42518 else if(equal(reject)) { type = 2; return true; }
42519 else if(equal(reject)) { type = 3; return true; }
42520 else { type = 4; return true;}
42524 template<typename V> bool encode(V& v) const
42526 return v(ref_nested());
42530 template<typename V> bool decode(size_t index, V& v)
42535 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42536 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
42537 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
42538 case 4: type = 4; return v(ref_nested());
42539 ref_nested().clear();
42544 template<typename V> bool encode(size_t index, V& v) const
42546 if(index != type) {return false;} return v(ref_nested());
42553 struct Value_t : asn::typefield<true>
42555 ~Value_t() {clear();}
42556 size_t get_index() const {return type;}
42557 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
42558 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
42559 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
42560 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
42561 ListofNRCellsinNRCoordinationResp& select_id_ListofNRCellsinNRCoordinationResp() { return set<ListofNRCellsinNRCoordinationResp>(3); }
42562 ListofNRCellsinNRCoordinationResp const* get_id_ListofNRCellsinNRCoordinationResp() const { return get<ListofNRCellsinNRCoordinationResp>(3); }
42563 bool is_unknown() const { return type == 4; }
42568 case 1: var.destroy<DataTrafficResourceIndication>(); break;
42569 case 2: var.destroy<SpectrumSharingGroupID>(); break;
42570 case 3: var.destroy<ListofNRCellsinNRCoordinationResp>(); break;
42572 type = 0; ref_nested().clear();
42574 template<typename V> static inline void enumerate(V& v)
42576 v.template operator()<DataTrafficResourceIndication>(1);
42577 v.template operator()<SpectrumSharingGroupID>(2);
42578 v.template operator()<ListofNRCellsinNRCoordinationResp>(3);
42582 template<typename V> bool decode(size_t index, V& v)
42587 case 1: v(select_id_DataTrafficResourceIndication()); return true;
42588 case 2: v(select_id_SpectrumSharingGroupID()); return true;
42589 case 3: v(select_id_ListofNRCellsinNRCoordinationResp()); return true;
42590 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
42595 template<typename V> bool encode(size_t index, V& v) const
42597 if(index != type) return false;
42600 case 1: v(var.as<DataTrafficResourceIndication>()); return true;
42601 case 2: v(var.as<SpectrumSharingGroupID>()); return true;
42602 case 3: v(var.as<ListofNRCellsinNRCoordinationResp>()); return true;
42608 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42609 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42612 char dummy1[sizeof(DataTrafficResourceIndication)];
42613 char dummy2[sizeof(ListofNRCellsinNRCoordinationResp)];
42614 char dummy3[sizeof(SpectrumSharingGroupID)];
42617 asn::variant<sizeof(union_type)> var;
42621 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42623 size_t get_index() const {return type;}
42624 bool is_unknown() const { return type == 4; }
42625 void clear() {type = 0;}
42626 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
42627 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
42628 void select_id_ListofNRCellsinNRCoordinationResp() { set(mandatory); type=3;}
42629 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42630 template<typename V> bool decode(V& v)
42633 if(!v(ref_nested())) return false;
42634 if(equal(mandatory)) { type = 1; return true; }
42635 else if(equal(mandatory)) { type = 2; return true; }
42636 else if(equal(mandatory)) { type = 3; return true; }
42637 else { type = 4; return true;}
42641 template<typename V> bool encode(V& v) const
42643 return v(ref_nested());
42647 template<typename V> bool decode(size_t index, V& v)
42652 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42653 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
42654 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
42655 case 4: type = 4; return v(ref_nested());
42656 ref_nested().clear();
42661 template<typename V> bool encode(size_t index, V& v) const
42663 if(index != type) {return false;} return v(ref_nested());
42673 RespondingNodeType-EutranrCellResourceCoordination ::= CHOICE {
42674 respond-eNB ProtocolIE-Container {{ENB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
42675 respond-en-gNB ProtocolIE-Container {{En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
42680 struct RespondingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
42682 static constexpr const char* name() {return "RespondingNodeType-EutranrCellResourceCoordination";}
42683 using parent_t = asn::choice<2, 0, true>;
42684 index_type get_index() const {return index;}
42685 bool is_unknown() const {return index == 3;}
42686 void set_unknown() { set_index(3); }
42687 ~RespondingNodeType_EutranrCellResourceCoordination() {clear();}
42688 struct respond_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>
42690 static constexpr const char* name() {return "respond_eNB_t";}
42691 using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
42694 struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>
42696 static constexpr const char* name() {return "respond_en_gNB_t";}
42697 using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
42702 switch(get_index())
42704 case 1: var.destroy<respond_eNB_t>(); break;
42705 case 2: var.destroy<respond_en_gNB_t>(); break;
42710 template<typename V> bool decode(size_t idx, V& v)
42715 case 1: set_index(1); return v(var.build<respond_eNB_t>());
42716 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
42721 template<typename V> bool encode(V& v) const
42723 switch(get_index())
42725 case 1: return v(var.as<respond_eNB_t>());
42726 case 2: return v(var.as<respond_en_gNB_t>());
42730 template<typename V> static inline void enumerate(V& v)
42732 v.template operator()<respond_eNB_t>(1);
42733 v.template operator()<respond_en_gNB_t>(2);
42736 respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
42737 respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
42738 respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
42739 respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
42741 void set_index(index_type i) {index = i; base::set();}
42744 char dummy1[sizeof(respond_eNB_t)];
42745 char dummy2[sizeof(respond_en_gNB_t)];
42748 asn::variant<sizeof(union_type)> var;
42749 index_type index {0};
42752 EUTRANRCellResourceCoordinationResponse-IEs X2AP-PROTOCOL-IES ::= {
42753 { ID id-RespondingNodeType-EutranrCellResourceCoordination CRITICALITY reject TYPE RespondingNodeType-EutranrCellResourceCoordination PRESENCE mandatory},
42758 struct EUTRANRCellResourceCoordinationResponse_IEs
42760 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42762 size_t get_index() const {return type;}
42763 bool is_unknown() const { return type == 2; }
42764 void clear() {type = 0;}
42765 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(id_RespondingNodeType_EutranrCellResourceCoordination); type=1;}
42766 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42767 template<typename V> bool decode(V& v)
42770 if(!v(ref_nested())) return false;
42771 if(equal(id_RespondingNodeType_EutranrCellResourceCoordination)) { type = 1; return true; }
42772 else { type = 2; return true;}
42776 template<typename V> bool encode(V& v) const
42778 return v(ref_nested());
42782 template<typename V> bool decode(size_t index, V& v)
42787 case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EutranrCellResourceCoordination);} return false;
42788 case 2: type = 2; return v(ref_nested());
42789 ref_nested().clear();
42794 template<typename V> bool encode(size_t index, V& v) const
42796 if(index != type) {return false;} return v(ref_nested());
42803 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42805 size_t get_index() const {return type;}
42806 bool is_unknown() const { return type == 2; }
42807 void clear() {type = 0;}
42808 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(reject); type=1;}
42809 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42810 template<typename V> bool decode(V& v)
42813 if(!v(ref_nested())) return false;
42814 if(equal(reject)) { type = 1; return true; }
42815 else { type = 2; return true;}
42819 template<typename V> bool encode(V& v) const
42821 return v(ref_nested());
42825 template<typename V> bool decode(size_t index, V& v)
42830 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42831 case 2: type = 2; return v(ref_nested());
42832 ref_nested().clear();
42837 template<typename V> bool encode(size_t index, V& v) const
42839 if(index != type) {return false;} return v(ref_nested());
42846 struct Value_t : asn::typefield<true>
42848 ~Value_t() {clear();}
42849 size_t get_index() const {return type;}
42850 RespondingNodeType_EutranrCellResourceCoordination& select_id_RespondingNodeType_EutranrCellResourceCoordination() { return set<RespondingNodeType_EutranrCellResourceCoordination>(1); }
42851 RespondingNodeType_EutranrCellResourceCoordination const* get_id_RespondingNodeType_EutranrCellResourceCoordination() const { return get<RespondingNodeType_EutranrCellResourceCoordination>(1); }
42852 bool is_unknown() const { return type == 2; }
42857 case 1: var.destroy<RespondingNodeType_EutranrCellResourceCoordination>(); break;
42859 type = 0; ref_nested().clear();
42861 template<typename V> static inline void enumerate(V& v)
42863 v.template operator()<RespondingNodeType_EutranrCellResourceCoordination>(1);
42867 template<typename V> bool decode(size_t index, V& v)
42872 case 1: v(select_id_RespondingNodeType_EutranrCellResourceCoordination()); return true;
42873 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
42878 template<typename V> bool encode(size_t index, V& v) const
42880 if(index != type) return false;
42883 case 1: v(var.as<RespondingNodeType_EutranrCellResourceCoordination>()); return true;
42889 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42890 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42893 char dummy1[sizeof(RespondingNodeType_EutranrCellResourceCoordination)];
42896 asn::variant<sizeof(union_type)> var;
42900 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42902 size_t get_index() const {return type;}
42903 bool is_unknown() const { return type == 2; }
42904 void clear() {type = 0;}
42905 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(mandatory); type=1;}
42906 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42907 template<typename V> bool decode(V& v)
42910 if(!v(ref_nested())) return false;
42911 if(equal(mandatory)) { type = 1; return true; }
42912 else { type = 2; return true;}
42916 template<typename V> bool encode(V& v) const
42918 return v(ref_nested());
42922 template<typename V> bool decode(size_t index, V& v)
42927 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42928 case 2: type = 2; return v(ref_nested());
42929 ref_nested().clear();
42934 template<typename V> bool encode(size_t index, V& v) const
42936 if(index != type) {return false;} return v(ref_nested());
42946 EUTRANRCellResourceCoordinationResponse ::= SEQUENCE {
42947 protocolIEs ProtocolIE-Container {{EUTRANRCellResourceCoordinationResponse-IEs}},
42952 struct EUTRANRCellResourceCoordinationResponse : asn::sequence<1, 0, true, 0>
42954 static constexpr const char* name() {return "EUTRANRCellResourceCoordinationResponse";}
42955 using parent_t = asn::sequence<1, 0, true, 0>;
42956 struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>
42958 static constexpr const char* name() {return "protocolIEs_t";}
42959 using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>;
42962 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
42963 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
42964 template<typename V> void decode(V& v)
42969 template<typename V> void encode(V& v) const
42976 protocolIEs.clear();
42980 protocolIEs_t protocolIEs;
42984 ErrorIndication-IEs X2AP-PROTOCOL-IES ::= {
42985 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE optional}|
42986 { ID id-New-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE optional}|
42987 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE optional}|
42988 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
42989 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
42990 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
42991 { ID id-Old-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE optional},
42996 struct ErrorIndication_IEs
42998 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43000 size_t get_index() const {return type;}
43001 bool is_unknown() const { return type == 8; }
43002 void clear() {type = 0;}
43003 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43004 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
43005 void select_id_Cause() { set(id_Cause); type=3;}
43006 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
43007 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=5;}
43008 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=6;}
43009 void select_id_Old_SgNB_UE_X2AP_ID() { set(id_Old_SgNB_UE_X2AP_ID); type=7;}
43010 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43011 template<typename V> bool decode(V& v)
43014 if(!v(ref_nested())) return false;
43015 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43016 else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
43017 else if(equal(id_Cause)) { type = 3; return true; }
43018 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
43019 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
43020 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
43021 else if(equal(id_Old_SgNB_UE_X2AP_ID)) { type = 7; return true; }
43022 else { type = 8; return true;}
43026 template<typename V> bool encode(V& v) const
43028 return v(ref_nested());
43032 template<typename V> bool decode(size_t index, V& v)
43037 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43038 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
43039 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
43040 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
43041 case 5: type = 5; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43042 case 6: type = 6; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
43043 case 7: type = 7; if(v(ref_nested())) { return equal(id_Old_SgNB_UE_X2AP_ID);} return false;
43044 case 8: type = 8; return v(ref_nested());
43045 ref_nested().clear();
43050 template<typename V> bool encode(size_t index, V& v) const
43052 if(index != type) {return false;} return v(ref_nested());
43059 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43061 size_t get_index() const {return type;}
43062 bool is_unknown() const { return type == 8; }
43063 void clear() {type = 0;}
43064 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
43065 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
43066 void select_id_Cause() { set(ignore); type=3;}
43067 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
43068 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
43069 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
43070 void select_id_Old_SgNB_UE_X2AP_ID() { set(ignore); type=7;}
43071 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43072 template<typename V> bool decode(V& v)
43075 if(!v(ref_nested())) return false;
43076 if(equal(ignore)) { type = 1; return true; }
43077 else if(equal(ignore)) { type = 2; return true; }
43078 else if(equal(ignore)) { type = 3; return true; }
43079 else if(equal(ignore)) { type = 4; return true; }
43080 else if(equal(ignore)) { type = 5; return true; }
43081 else if(equal(ignore)) { type = 6; return true; }
43082 else if(equal(ignore)) { type = 7; return true; }
43083 else { type = 8; return true;}
43087 template<typename V> bool encode(V& v) const
43089 return v(ref_nested());
43093 template<typename V> bool decode(size_t index, V& v)
43098 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43099 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43100 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43101 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
43102 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
43103 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
43104 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
43105 case 8: type = 8; return v(ref_nested());
43106 ref_nested().clear();
43111 template<typename V> bool encode(size_t index, V& v) const
43113 if(index != type) {return false;} return v(ref_nested());
43120 struct Value_t : asn::typefield<true>
43122 ~Value_t() {clear();}
43123 size_t get_index() const {return type;}
43124 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43125 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43126 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
43127 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
43128 Cause& select_id_Cause() { return set<Cause>(3); }
43129 Cause const* get_id_Cause() const { return get<Cause>(3); }
43130 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
43131 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
43132 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
43133 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
43134 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
43135 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
43136 SgNB_UE_X2AP_ID& select_id_Old_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(7); }
43137 SgNB_UE_X2AP_ID const* get_id_Old_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(7); }
43138 bool is_unknown() const { return type == 8; }
43143 case 1: var.destroy<UE_X2AP_ID>(); break;
43144 case 2: var.destroy<UE_X2AP_ID>(); break;
43145 case 3: var.destroy<Cause>(); break;
43146 case 4: var.destroy<CriticalityDiagnostics>(); break;
43147 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
43148 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
43149 case 7: var.destroy<SgNB_UE_X2AP_ID>(); break;
43151 type = 0; ref_nested().clear();
43153 template<typename V> static inline void enumerate(V& v)
43155 v.template operator()<UE_X2AP_ID>(1);
43156 v.template operator()<UE_X2AP_ID>(2);
43157 v.template operator()<Cause>(3);
43158 v.template operator()<CriticalityDiagnostics>(4);
43159 v.template operator()<UE_X2AP_ID_Extension>(5);
43160 v.template operator()<UE_X2AP_ID_Extension>(6);
43161 v.template operator()<SgNB_UE_X2AP_ID>(7);
43165 template<typename V> bool decode(size_t index, V& v)
43170 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
43171 case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
43172 case 3: v(select_id_Cause()); return true;
43173 case 4: v(select_id_CriticalityDiagnostics()); return true;
43174 case 5: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
43175 case 6: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
43176 case 7: v(select_id_Old_SgNB_UE_X2AP_ID()); return true;
43177 case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
43182 template<typename V> bool encode(size_t index, V& v) const
43184 if(index != type) return false;
43187 case 1: v(var.as<UE_X2AP_ID>()); return true;
43188 case 2: v(var.as<UE_X2AP_ID>()); return true;
43189 case 3: v(var.as<Cause>()); return true;
43190 case 4: v(var.as<CriticalityDiagnostics>()); return true;
43191 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
43192 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
43193 case 7: v(var.as<SgNB_UE_X2AP_ID>()); return true;
43199 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43200 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43203 char dummy1[sizeof(Cause)];
43204 char dummy2[sizeof(CriticalityDiagnostics)];
43205 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
43206 char dummy4[sizeof(UE_X2AP_ID)];
43207 char dummy5[sizeof(UE_X2AP_ID_Extension)];
43210 asn::variant<sizeof(union_type)> var;
43214 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43216 size_t get_index() const {return type;}
43217 bool is_unknown() const { return type == 8; }
43218 void clear() {type = 0;}
43219 void select_id_Old_eNB_UE_X2AP_ID() { set(optional); type=1;}
43220 void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
43221 void select_id_Cause() { set(optional); type=3;}
43222 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
43223 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
43224 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
43225 void select_id_Old_SgNB_UE_X2AP_ID() { set(optional); type=7;}
43226 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43227 template<typename V> bool decode(V& v)
43230 if(!v(ref_nested())) return false;
43231 if(equal(optional)) { type = 1; return true; }
43232 else if(equal(optional)) { type = 2; return true; }
43233 else if(equal(optional)) { type = 3; return true; }
43234 else if(equal(optional)) { type = 4; return true; }
43235 else if(equal(optional)) { type = 5; return true; }
43236 else if(equal(optional)) { type = 6; return true; }
43237 else if(equal(optional)) { type = 7; return true; }
43238 else { type = 8; return true;}
43242 template<typename V> bool encode(V& v) const
43244 return v(ref_nested());
43248 template<typename V> bool decode(size_t index, V& v)
43253 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
43254 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
43255 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
43256 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
43257 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
43258 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
43259 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
43260 case 8: type = 8; return v(ref_nested());
43261 ref_nested().clear();
43266 template<typename V> bool encode(size_t index, V& v) const
43268 if(index != type) {return false;} return v(ref_nested());
43278 ErrorIndication ::= SEQUENCE {
43279 protocolIEs ProtocolIE-Container {{ErrorIndication-IEs}},
43284 struct ErrorIndication : asn::sequence<1, 0, true, 0>
43286 static constexpr const char* name() {return "ErrorIndication";}
43287 using parent_t = asn::sequence<1, 0, true, 0>;
43288 struct protocolIEs_t : ProtocolIE_Container<ErrorIndication_IEs>
43290 static constexpr const char* name() {return "protocolIEs_t";}
43291 using parent_t = ProtocolIE_Container<ErrorIndication_IEs>;
43294 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43295 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43296 template<typename V> void decode(V& v)
43301 template<typename V> void encode(V& v) const
43308 protocolIEs.clear();
43312 protocolIEs_t protocolIEs;
43316 GNBStatusIndicationIEs X2AP-PROTOCOL-IES ::= {
43317 { ID id-GNBOverloadInformation CRITICALITY ignore TYPE GNBOverloadInformation PRESENCE mandatory},
43322 struct GNBStatusIndicationIEs
43324 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43326 size_t get_index() const {return type;}
43327 bool is_unknown() const { return type == 2; }
43328 void clear() {type = 0;}
43329 void select_id_GNBOverloadInformation() { set(id_GNBOverloadInformation); type=1;}
43330 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43331 template<typename V> bool decode(V& v)
43334 if(!v(ref_nested())) return false;
43335 if(equal(id_GNBOverloadInformation)) { type = 1; return true; }
43336 else { type = 2; return true;}
43340 template<typename V> bool encode(V& v) const
43342 return v(ref_nested());
43346 template<typename V> bool decode(size_t index, V& v)
43351 case 1: type = 1; if(v(ref_nested())) { return equal(id_GNBOverloadInformation);} return false;
43352 case 2: type = 2; return v(ref_nested());
43353 ref_nested().clear();
43358 template<typename V> bool encode(size_t index, V& v) const
43360 if(index != type) {return false;} return v(ref_nested());
43367 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43369 size_t get_index() const {return type;}
43370 bool is_unknown() const { return type == 2; }
43371 void clear() {type = 0;}
43372 void select_id_GNBOverloadInformation() { set(ignore); type=1;}
43373 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43374 template<typename V> bool decode(V& v)
43377 if(!v(ref_nested())) return false;
43378 if(equal(ignore)) { type = 1; return true; }
43379 else { type = 2; return true;}
43383 template<typename V> bool encode(V& v) const
43385 return v(ref_nested());
43389 template<typename V> bool decode(size_t index, V& v)
43394 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43395 case 2: type = 2; return v(ref_nested());
43396 ref_nested().clear();
43401 template<typename V> bool encode(size_t index, V& v) const
43403 if(index != type) {return false;} return v(ref_nested());
43410 struct Value_t : asn::typefield<true>
43412 ~Value_t() {clear();}
43413 size_t get_index() const {return type;}
43414 GNBOverloadInformation& select_id_GNBOverloadInformation() { return set<GNBOverloadInformation>(1); }
43415 GNBOverloadInformation const* get_id_GNBOverloadInformation() const { return get<GNBOverloadInformation>(1); }
43416 bool is_unknown() const { return type == 2; }
43421 case 1: var.destroy<GNBOverloadInformation>(); break;
43423 type = 0; ref_nested().clear();
43425 template<typename V> static inline void enumerate(V& v)
43427 v.template operator()<GNBOverloadInformation>(1);
43431 template<typename V> bool decode(size_t index, V& v)
43436 case 1: v(select_id_GNBOverloadInformation()); return true;
43437 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
43442 template<typename V> bool encode(size_t index, V& v) const
43444 if(index != type) return false;
43447 case 1: v(var.as<GNBOverloadInformation>()); return true;
43453 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43454 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43457 char dummy1[sizeof(GNBOverloadInformation)];
43460 asn::variant<sizeof(union_type)> var;
43464 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43466 size_t get_index() const {return type;}
43467 bool is_unknown() const { return type == 2; }
43468 void clear() {type = 0;}
43469 void select_id_GNBOverloadInformation() { set(mandatory); type=1;}
43470 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43471 template<typename V> bool decode(V& v)
43474 if(!v(ref_nested())) return false;
43475 if(equal(mandatory)) { type = 1; return true; }
43476 else { type = 2; return true;}
43480 template<typename V> bool encode(V& v) const
43482 return v(ref_nested());
43486 template<typename V> bool decode(size_t index, V& v)
43491 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
43492 case 2: type = 2; return v(ref_nested());
43493 ref_nested().clear();
43498 template<typename V> bool encode(size_t index, V& v) const
43500 if(index != type) {return false;} return v(ref_nested());
43510 GNBStatusIndication ::= SEQUENCE {
43511 protocolIEs ProtocolIE-Container { { GNBStatusIndicationIEs} },
43516 struct GNBStatusIndication : asn::sequence<1, 0, true, 0>
43518 static constexpr const char* name() {return "GNBStatusIndication";}
43519 using parent_t = asn::sequence<1, 0, true, 0>;
43520 struct protocolIEs_t : ProtocolIE_Container<GNBStatusIndicationIEs>
43522 static constexpr const char* name() {return "protocolIEs_t";}
43523 using parent_t = ProtocolIE_Container<GNBStatusIndicationIEs>;
43526 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43527 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43528 template<typename V> void decode(V& v)
43533 template<typename V> void encode(V& v) const
43540 protocolIEs.clear();
43544 protocolIEs_t protocolIEs;
43548 HandoverCancel-IEs X2AP-PROTOCOL-IES ::= {
43549 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
43550 { ID id-New-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE optional}|
43551 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
43552 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
43553 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
43558 struct HandoverCancel_IEs
43560 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43562 size_t get_index() const {return type;}
43563 bool is_unknown() const { return type == 6; }
43564 void clear() {type = 0;}
43565 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43566 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
43567 void select_id_Cause() { set(id_Cause); type=3;}
43568 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
43569 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
43570 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43571 template<typename V> bool decode(V& v)
43574 if(!v(ref_nested())) return false;
43575 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43576 else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
43577 else if(equal(id_Cause)) { type = 3; return true; }
43578 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
43579 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
43580 else { type = 6; return true;}
43584 template<typename V> bool encode(V& v) const
43586 return v(ref_nested());
43590 template<typename V> bool decode(size_t index, V& v)
43595 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43596 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
43597 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
43598 case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43599 case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
43600 case 6: type = 6; return v(ref_nested());
43601 ref_nested().clear();
43606 template<typename V> bool encode(size_t index, V& v) const
43608 if(index != type) {return false;} return v(ref_nested());
43615 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43617 size_t get_index() const {return type;}
43618 bool is_unknown() const { return type == 6; }
43619 void clear() {type = 0;}
43620 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
43621 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
43622 void select_id_Cause() { set(ignore); type=3;}
43623 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
43624 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
43625 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43626 template<typename V> bool decode(V& v)
43629 if(!v(ref_nested())) return false;
43630 if(equal(reject)) { type = 1; return true; }
43631 else if(equal(ignore)) { type = 2; return true; }
43632 else if(equal(ignore)) { type = 3; return true; }
43633 else if(equal(reject)) { type = 4; return true; }
43634 else if(equal(ignore)) { type = 5; return true; }
43635 else { type = 6; return true;}
43639 template<typename V> bool encode(V& v) const
43641 return v(ref_nested());
43645 template<typename V> bool decode(size_t index, V& v)
43650 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
43651 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43652 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43653 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
43654 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
43655 case 6: type = 6; return v(ref_nested());
43656 ref_nested().clear();
43661 template<typename V> bool encode(size_t index, V& v) const
43663 if(index != type) {return false;} return v(ref_nested());
43670 struct Value_t : asn::typefield<true>
43672 ~Value_t() {clear();}
43673 size_t get_index() const {return type;}
43674 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43675 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43676 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
43677 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
43678 Cause& select_id_Cause() { return set<Cause>(3); }
43679 Cause const* get_id_Cause() const { return get<Cause>(3); }
43680 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
43681 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
43682 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
43683 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
43684 bool is_unknown() const { return type == 6; }
43689 case 1: var.destroy<UE_X2AP_ID>(); break;
43690 case 2: var.destroy<UE_X2AP_ID>(); break;
43691 case 3: var.destroy<Cause>(); break;
43692 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
43693 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
43695 type = 0; ref_nested().clear();
43697 template<typename V> static inline void enumerate(V& v)
43699 v.template operator()<UE_X2AP_ID>(1);
43700 v.template operator()<UE_X2AP_ID>(2);
43701 v.template operator()<Cause>(3);
43702 v.template operator()<UE_X2AP_ID_Extension>(4);
43703 v.template operator()<UE_X2AP_ID_Extension>(5);
43707 template<typename V> bool decode(size_t index, V& v)
43712 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
43713 case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
43714 case 3: v(select_id_Cause()); return true;
43715 case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
43716 case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
43717 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
43722 template<typename V> bool encode(size_t index, V& v) const
43724 if(index != type) return false;
43727 case 1: v(var.as<UE_X2AP_ID>()); return true;
43728 case 2: v(var.as<UE_X2AP_ID>()); return true;
43729 case 3: v(var.as<Cause>()); return true;
43730 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
43731 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
43737 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43738 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43741 char dummy1[sizeof(Cause)];
43742 char dummy2[sizeof(UE_X2AP_ID)];
43743 char dummy3[sizeof(UE_X2AP_ID_Extension)];
43746 asn::variant<sizeof(union_type)> var;
43750 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43752 size_t get_index() const {return type;}
43753 bool is_unknown() const { return type == 6; }
43754 void clear() {type = 0;}
43755 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
43756 void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
43757 void select_id_Cause() { set(mandatory); type=3;}
43758 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
43759 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
43760 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43761 template<typename V> bool decode(V& v)
43764 if(!v(ref_nested())) return false;
43765 if(equal(mandatory)) { type = 1; return true; }
43766 else if(equal(optional)) { type = 2; return true; }
43767 else if(equal(mandatory)) { type = 3; return true; }
43768 else if(equal(optional)) { type = 4; return true; }
43769 else if(equal(optional)) { type = 5; return true; }
43770 else { type = 6; return true;}
43774 template<typename V> bool encode(V& v) const
43776 return v(ref_nested());
43780 template<typename V> bool decode(size_t index, V& v)
43785 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
43786 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
43787 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
43788 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
43789 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
43790 case 6: type = 6; return v(ref_nested());
43791 ref_nested().clear();
43796 template<typename V> bool encode(size_t index, V& v) const
43798 if(index != type) {return false;} return v(ref_nested());
43808 HandoverCancel ::= SEQUENCE {
43809 protocolIEs ProtocolIE-Container {{HandoverCancel-IEs}},
43814 struct HandoverCancel : asn::sequence<1, 0, true, 0>
43816 static constexpr const char* name() {return "HandoverCancel";}
43817 using parent_t = asn::sequence<1, 0, true, 0>;
43818 struct protocolIEs_t : ProtocolIE_Container<HandoverCancel_IEs>
43820 static constexpr const char* name() {return "protocolIEs_t";}
43821 using parent_t = ProtocolIE_Container<HandoverCancel_IEs>;
43824 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43825 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43826 template<typename V> void decode(V& v)
43831 template<typename V> void encode(V& v) const
43838 protocolIEs.clear();
43842 protocolIEs_t protocolIEs;
43846 HandoverPreparationFailure-IEs X2AP-PROTOCOL-IES ::= {
43847 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
43848 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
43849 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
43850 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
43856 struct HandoverPreparationFailure_IEs
43858 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43860 size_t get_index() const {return type;}
43861 bool is_unknown() const { return type == 5; }
43862 void clear() {type = 0;}
43863 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43864 void select_id_Cause() { set(id_Cause); type=2;}
43865 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
43866 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
43867 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43868 template<typename V> bool decode(V& v)
43871 if(!v(ref_nested())) return false;
43872 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43873 else if(equal(id_Cause)) { type = 2; return true; }
43874 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
43875 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
43876 else { type = 5; return true;}
43880 template<typename V> bool encode(V& v) const
43882 return v(ref_nested());
43886 template<typename V> bool decode(size_t index, V& v)
43891 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43892 case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
43893 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
43894 case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43895 case 5: type = 5; return v(ref_nested());
43896 ref_nested().clear();
43901 template<typename V> bool encode(size_t index, V& v) const
43903 if(index != type) {return false;} return v(ref_nested());
43910 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43912 size_t get_index() const {return type;}
43913 bool is_unknown() const { return type == 5; }
43914 void clear() {type = 0;}
43915 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
43916 void select_id_Cause() { set(ignore); type=2;}
43917 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
43918 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
43919 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43920 template<typename V> bool decode(V& v)
43923 if(!v(ref_nested())) return false;
43924 if(equal(ignore)) { type = 1; return true; }
43925 else if(equal(ignore)) { type = 2; return true; }
43926 else if(equal(ignore)) { type = 3; return true; }
43927 else if(equal(ignore)) { type = 4; return true; }
43928 else { type = 5; return true;}
43932 template<typename V> bool encode(V& v) const
43934 return v(ref_nested());
43938 template<typename V> bool decode(size_t index, V& v)
43943 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43944 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43945 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43946 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
43947 case 5: type = 5; return v(ref_nested());
43948 ref_nested().clear();
43953 template<typename V> bool encode(size_t index, V& v) const
43955 if(index != type) {return false;} return v(ref_nested());
43962 struct Value_t : asn::typefield<true>
43964 ~Value_t() {clear();}
43965 size_t get_index() const {return type;}
43966 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43967 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43968 Cause& select_id_Cause() { return set<Cause>(2); }
43969 Cause const* get_id_Cause() const { return get<Cause>(2); }
43970 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
43971 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
43972 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
43973 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
43974 bool is_unknown() const { return type == 5; }
43979 case 1: var.destroy<UE_X2AP_ID>(); break;
43980 case 2: var.destroy<Cause>(); break;
43981 case 3: var.destroy<CriticalityDiagnostics>(); break;
43982 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
43984 type = 0; ref_nested().clear();
43986 template<typename V> static inline void enumerate(V& v)
43988 v.template operator()<UE_X2AP_ID>(1);
43989 v.template operator()<Cause>(2);
43990 v.template operator()<CriticalityDiagnostics>(3);
43991 v.template operator()<UE_X2AP_ID_Extension>(4);
43995 template<typename V> bool decode(size_t index, V& v)
44000 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
44001 case 2: v(select_id_Cause()); return true;
44002 case 3: v(select_id_CriticalityDiagnostics()); return true;
44003 case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
44004 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
44009 template<typename V> bool encode(size_t index, V& v) const
44011 if(index != type) return false;
44014 case 1: v(var.as<UE_X2AP_ID>()); return true;
44015 case 2: v(var.as<Cause>()); return true;
44016 case 3: v(var.as<CriticalityDiagnostics>()); return true;
44017 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
44023 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44024 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44027 char dummy1[sizeof(Cause)];
44028 char dummy2[sizeof(CriticalityDiagnostics)];
44029 char dummy3[sizeof(UE_X2AP_ID)];
44030 char dummy4[sizeof(UE_X2AP_ID_Extension)];
44033 asn::variant<sizeof(union_type)> var;
44037 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
44039 size_t get_index() const {return type;}
44040 bool is_unknown() const { return type == 5; }
44041 void clear() {type = 0;}
44042 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
44043 void select_id_Cause() { set(mandatory); type=2;}
44044 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
44045 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
44046 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
44047 template<typename V> bool decode(V& v)
44050 if(!v(ref_nested())) return false;
44051 if(equal(mandatory)) { type = 1; return true; }
44052 else if(equal(mandatory)) { type = 2; return true; }
44053 else if(equal(optional)) { type = 3; return true; }
44054 else if(equal(optional)) { type = 4; return true; }
44055 else { type = 5; return true;}
44059 template<typename V> bool encode(V& v) const
44061 return v(ref_nested());
44065 template<typename V> bool decode(size_t index, V& v)
44070 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
44071 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
44072 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
44073 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
44074 case 5: type = 5; return v(ref_nested());
44075 ref_nested().clear();
44080 template<typename V> bool encode(size_t index, V& v) const
44082 if(index != type) {return false;} return v(ref_nested());
44092 HandoverPreparationFailure ::= SEQUENCE {
44093 protocolIEs ProtocolIE-Container {{HandoverPreparationFailure-IEs}},
44098 struct HandoverPreparationFailure : asn::sequence<1, 0, true, 0>
44100 static constexpr const char* name() {return "HandoverPreparationFailure";}
44101 using parent_t = asn::sequence<1, 0, true, 0>;
44102 struct protocolIEs_t : ProtocolIE_Container<HandoverPreparationFailure_IEs>
44104 static constexpr const char* name() {return "protocolIEs_t";}
44105 using parent_t = ProtocolIE_Container<HandoverPreparationFailure_IEs>;
44108 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
44109 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
44110 template<typename V> void decode(V& v)
44115 template<typename V> void encode(V& v) const
44122 protocolIEs.clear();
44126 protocolIEs_t protocolIEs;
44130 MobilityInformation ::= BIT STRING (SIZE(32))
44133 struct MobilityInformation : asn::bstring<>
44135 using constraint_t = asn::constraints<false,asn::one<32>>;
44136 static constexpr const char* name() {return "MobilityInformation";}
44137 using parent_t = asn::bstring<>;
44142 HandoverReport-IEs X2AP-PROTOCOL-IES ::= {
44143 { ID id-HandoverReportType CRITICALITY ignore TYPE HandoverReportType PRESENCE mandatory}|
44144 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
44145 { ID id-SourceCellECGI CRITICALITY ignore TYPE ECGI PRESENCE mandatory}|
44146 { ID id-FailureCellECGI CRITICALITY ignore TYPE ECGI PRESENCE mandatory}|
44147 { ID id-Re-establishmentCellECGI CRITICALITY ignore TYPE ECGI PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to “HO to Wrong Cell” -- |
44148 { ID id-TargetCellInUTRAN CRITICALITY ignore TYPE TargetCellInUTRAN PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to "InterRAT ping-pong" --|
44149 { ID id-SourceCellCRNTI CRITICALITY ignore TYPE CRNTI PRESENCE optional}|
44150 { ID id-MobilityInformation CRITICALITY ignore TYPE MobilityInformation PRESENCE optional}|
44151 { ID id-UE-RLF-Report-Container CRITICALITY ignore TYPE UE-RLF-Report-Container PRESENCE optional}|
44152 { ID id-UE-RLF-Report-Container-for-extended-bands CRITICALITY ignore TYPE UE-RLF-Report-Container-for-extended-bands PRESENCE optional},
44157 struct HandoverReport_IEs
44159 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
44161 size_t get_index() const {return type;}
44162 bool is_unknown() const { return type == 11; }
44163 void clear() {type = 0;}
44164 void select_id_HandoverReportType() { set(id_HandoverReportType); type=1;}
44165 void select_id_Cause() { set(id_Cause); type=2;}
44166 void select_id_SourceCellECGI() { set(id_SourceCellECGI); type=3;}
44167 void select_id_FailureCellECGI() { set(id_FailureCellECGI); type=4;}
44168 void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=5;}
44169 void select_id_TargetCellInUTRAN() { set(id_TargetCellInUTRAN); type=6;}
44170 void select_id_SourceCellCRNTI() { set(id_SourceCellCRNTI); type=7;}
44171 void select_id_MobilityInformation() { set(id_MobilityInformation); type=8;}
44172 void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=9;}
44173 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=10;}
44174 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
44175 template<typename V> bool decode(V& v)
44178 if(!v(ref_nested())) return false;
44179 if(equal(id_HandoverReportType)) { type = 1; return true; }
44180 else if(equal(id_Cause)) { type = 2; return true; }
44181 else if(equal(id_SourceCellECGI)) { type = 3; return true; }
44182 else if(equal(id_FailureCellECGI)) { type = 4; return true; }
44183 else if(equal(id_Re_establishmentCellECGI)) { type = 5; return true; }
44184 else if(equal(id_TargetCellInUTRAN)) { type = 6; return true; }
44185 else if(equal(id_SourceCellCRNTI)) { type = 7; return true; }
44186 else if(equal(id_MobilityInformation)) { type = 8; return true; }
44187 else if(equal(id_UE_RLF_Report_Container)) { type = 9; return true; }
44188 else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 10; return true; }
44189 else { type = 11; return true;}
44193 template<typename V> bool encode(V& v) const
44195 return v(ref_nested());
44199 template<typename V> bool decode(size_t index, V& v)
44204 case 1: type = 1; if(v(ref_nested())) { return equal(id_HandoverReportType);} return false;
44205 case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
44206 case 3: type = 3; if(v(ref_nested())) { return equal(id_SourceCellECGI);} return false;
44207 case 4: type = 4; if(v(ref_nested())) { return equal(id_FailureCellECGI);} return false;
44208 case 5: type = 5; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
44209 case 6: type = 6; if(v(ref_nested())) { return equal(id_TargetCellInUTRAN);} return false;
44210 case 7: type = 7; if(v(ref_nested())) { return equal(id_SourceCellCRNTI);} return false;
44211 case 8: type = 8; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
44212 case 9: type = 9; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
44213 case 10: type = 10; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
44214 case 11: type = 11; return v(ref_nested());
44215 ref_nested().clear();
44220 template<typename V> bool encode(size_t index, V& v) const
44222 if(index != type) {return false;} return v(ref_nested());
44229 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
44231 size_t get_index() const {return type;}
44232 bool is_unknown() const { return type == 11; }
44233 void clear() {type = 0;}
44234 void select_id_HandoverReportType() { set(ignore); type=1;}
44235 void select_id_Cause() { set(ignore); type=2;}
44236 void select_id_SourceCellECGI() { set(ignore); type=3;}
44237 void select_id_FailureCellECGI() { set(ignore); type=4;}
44238 void select_id_Re_establishmentCellECGI() { set(ignore); type=5;}
44239 void select_id_TargetCellInUTRAN() { set(ignore); type=6;}
44240 void select_id_SourceCellCRNTI() { set(ignore); type=7;}
44241 void select_id_MobilityInformation() { set(ignore); type=8;}
44242 void select_id_UE_RLF_Report_Container() { set(ignore); type=9;}
44243 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=10;}
44244 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
44245 template<typename V> bool decode(V& v)
44248 if(!v(ref_nested())) return false;
44249 if(equal(ignore)) { type = 1; return true; }
44250 else if(equal(ignore)) { type = 2; return true; }
44251 else if(equal(ignore)) { type = 3; return true; }
44252 else if(equal(ignore)) { type = 4; return true; }
44253 else if(equal(ignore)) { type = 5; return true; }
44254 else if(equal(ignore)) { type = 6; return true; }
44255 else if(equal(ignore)) { type = 7; return true; }
44256 else if(equal(ignore)) { type = 8; return true; }
44257 else if(equal(ignore)) { type = 9; return true; }
44258 else if(equal(ignore)) { type = 10; return true; }
44259 else { type = 11; return true;}
44263 template<typename V> bool encode(V& v) const
44265 return v(ref_nested());
44269 template<typename V> bool decode(size_t index, V& v)
44274 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
44275 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
44276 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
44277 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
44278 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
44279 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
44280 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
44281 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
44282 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
44283 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
44284 case 11: type = 11; return v(ref_nested());
44285 ref_nested().clear();
44290 template<typename V> bool encode(size_t index, V& v) const
44292 if(index != type) {return false;} return v(ref_nested());
44299 struct Value_t : asn::typefield<true>
44301 ~Value_t() {clear();}
44302 size_t get_index() const {return type;}
44303 HandoverReportType& select_id_HandoverReportType() { return set<HandoverReportType>(1); }
44304 HandoverReportType const* get_id_HandoverReportType() const { return get<HandoverReportType>(1); }
44305 Cause& select_id_Cause() { return set<Cause>(2); }
44306 Cause const* get_id_Cause() const { return get<Cause>(2); }
44307 ECGI& select_id_SourceCellECGI() { return set<ECGI>(3); }
44308 ECGI const* get_id_SourceCellECGI() const { return get<ECGI>(3); }
44309 ECGI& select_id_FailureCellECGI() { return set<ECGI>(4); }
44310 ECGI const* get_id_FailureCellECGI() const { return get<ECGI>(4); }
44311 ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(5); }
44312 ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(5); }
44313 TargetCellInUTRAN& select_id_TargetCellInUTRAN() { return set<TargetCellInUTRAN>(6); }
44314 TargetCellInUTRAN const* get_id_TargetCellInUTRAN() const { return get<TargetCellInUTRAN>(6); }
44315 CRNTI& select_id_SourceCellCRNTI() { return set<CRNTI>(7); }
44316 CRNTI const* get_id_SourceCellCRNTI() const { return get<CRNTI>(7); }
44317 MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(8); }
44318 MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(8); }
44319 UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(9); }
44320 UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(9); }
44321 UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(10); }
44322 UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(10); }
44323 bool is_unknown() const { return type == 11; }
44328 case 1: var.destroy<HandoverReportType>(); break;
44329 case 2: var.destroy<Cause>(); break;
44330 case 3: var.destroy<ECGI>(); break;
44331 case 4: var.destroy<ECGI>(); break;
44332 case 5: var.destroy<ECGI>(); break;
44333 case 6: var.destroy<TargetCellInUTRAN>(); break;
44334 case 7: var.destroy<CRNTI>(); break;
44335 case 8: var.destroy<MobilityInformation>(); break;
44336 case 9: var.destroy<UE_RLF_Report_Container>(); break;
44337 case 10: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
44339 type = 0; ref_nested().clear();
44341 template<typename V> static inline void enumerate(V& v)
44343 v.template operator()<HandoverReportType>(1);
44344 v.template operator()<Cause>(2);
44345 v.template operator()<ECGI>(3);
44346 v.template operator()<ECGI>(4);
44347 v.template operator()<ECGI>(5);
44348 v.template operator()<TargetCellInUTRAN>(6);
44349 v.template operator()<CRNTI>(7);
44350 v.template operator()<MobilityInformation>(8);
44351 v.template operator()<UE_RLF_Report_Container>(9);
44352 v.template operator()<UE_RLF_Report_Container_for_extended_bands>(10);
44356 template<typename V> bool decode(size_t index, V& v)
44361 case 1: v(select_id_HandoverReportType()); return true;
44362 case 2: v(select_id_Cause()); return true;
44363 case 3: v(select_id_SourceCellECGI()); return true;
44364 case 4: v(select_id_FailureCellECGI()); return true;
44365 case 5: v(select_id_Re_establishmentCellECGI()); return true;
44366 case 6: v(select_id_TargetCellInUTRAN()); return true;
44367 case 7: v(select_id_SourceCellCRNTI()); return true;
44368 case 8: v(select_id_MobilityInformation()); return true;
44369 case 9: v(select_id_UE_RLF_Report_Container()); return true;
44370 case 10: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
44371 case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
44376 template<typename V> bool encode(size_t index, V& v) const
44378 if(index != type) return false;
44381 case 1: v(var.as<HandoverReportType>()); return true;
44382 case 2: v(var.as<Cause>()); return true;
44383 case 3: v(var.as<ECGI>()); return true;
44384 case 4: v(var.as<ECGI>()); return true;
44385 case 5: v(var.as<ECGI>()); return true;
44386 case 6: v(var.as<TargetCellInUTRAN>()); return true;
44387 case 7: v(var.as<CRNTI>()); return true;
44388 case 8: v(var.as<MobilityInformation>()); return true;
44389 case 9: v(var.as<UE_RLF_Report_Container>()); return true;
44390 case 10: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); return true;
44396 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44397 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44400 char dummy1[sizeof(CRNTI)];
44401 char dummy2[sizeof(Cause)];
44402 char dummy3[sizeof(ECGI)];
44403 char dummy4[sizeof(HandoverReportType)];
44404 char dummy5[sizeof(MobilityInformation)];
44405 char dummy6[sizeof(TargetCellInUTRAN)];
44406 char dummy7[sizeof(UE_RLF_Report_Container)];
44407 char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
44410 asn::variant<sizeof(union_type)> var;
44414 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
44416 size_t get_index() const {return type;}
44417 bool is_unknown() const { return type == 11; }
44418 void clear() {type = 0;}
44419 void select_id_HandoverReportType() { set(mandatory); type=1;}
44420 void select_id_Cause() { set(mandatory); type=2;}
44421 void select_id_SourceCellECGI() { set(mandatory); type=3;}
44422 void select_id_FailureCellECGI() { set(mandatory); type=4;}
44423 void select_id_Re_establishmentCellECGI() { set(conditional); type=5;}
44424 void select_id_TargetCellInUTRAN() { set(conditional); type=6;}
44425 void select_id_SourceCellCRNTI() { set(optional); type=7;}
44426 void select_id_MobilityInformation() { set(optional); type=8;}
44427 void select_id_UE_RLF_Report_Container() { set(optional); type=9;}
44428 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=10;}
44429 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
44430 template<typename V> bool decode(V& v)
44433 if(!v(ref_nested())) return false;
44434 if(equal(mandatory)) { type = 1; return true; }
44435 else if(equal(mandatory)) { type = 2; return true; }
44436 else if(equal(mandatory)) { type = 3; return true; }
44437 else if(equal(mandatory)) { type = 4; return true; }
44438 else if(equal(conditional)) { type = 5; return true; }
44439 else if(equal(conditional)) { type = 6; return true; }
44440 else if(equal(optional)) { type = 7; return true; }
44441 else if(equal(optional)) { type = 8; return true; }
44442 else if(equal(optional)) { type = 9; return true; }
44443 else if(equal(optional)) { type = 10; return true; }
44444 else { type = 11; return true;}
44448 template<typename V> bool encode(V& v) const
44450 return v(ref_nested());
44454 template<typename V> bool decode(size_t index, V& v)
44459 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
44460 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
44461 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
44462 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
44463 case 5: type = 5; if(v(ref_nested())) { return equal(conditional);} return false;
44464 case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
44465 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
44466 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
44467 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
44468 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
44469 case 11: type = 11; return v(ref_nested());
44470 ref_nested().clear();
44475 template<typename V> bool encode(size_t index, V& v) const
44477 if(index != type) {return false;} return v(ref_nested());
44487 HandoverReport ::= SEQUENCE {
44488 protocolIEs ProtocolIE-Container {{HandoverReport-IEs}},
44493 struct HandoverReport : asn::sequence<1, 0, true, 0>
44495 static constexpr const char* name() {return "HandoverReport";}
44496 using parent_t = asn::sequence<1, 0, true, 0>;
44497 struct protocolIEs_t : ProtocolIE_Container<HandoverReport_IEs>
44499 static constexpr const char* name() {return "protocolIEs_t";}
44500 using parent_t = ProtocolIE_Container<HandoverReport_IEs>;
44503 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
44504 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
44505 template<typename V> void decode(V& v)
44510 template<typename V> void encode(V& v) const
44517 protocolIEs.clear();
44521 protocolIEs_t protocolIEs;
44525 UE-ContextInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
44526 { ID id-ManagementBasedMDTallowed CRITICALITY ignore EXTENSION ManagementBasedMDTallowed PRESENCE optional }|
44527 { ID id-ManagementBasedMDTPLMNList CRITICALITY ignore EXTENSION MDTPLMNList PRESENCE optional }|
44528 { ID id-UESidelinkAggregateMaximumBitRate CRITICALITY ignore EXTENSION UESidelinkAggregateMaximumBitRate PRESENCE optional},
44533 struct UE_ContextInformation_ExtIEs
44535 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
44537 size_t get_index() const {return type;}
44538 bool is_unknown() const { return type == 4; }
44539 void clear() {type = 0;}
44540 void select_id_ManagementBasedMDTallowed() { set(id_ManagementBasedMDTallowed); type=1;}
44541 void select_id_ManagementBasedMDTPLMNList() { set(id_ManagementBasedMDTPLMNList); type=2;}
44542 void select_id_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); type=3;}
44543 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
44544 template<typename V> bool decode(V& v)
44547 if(!v(ref_nested())) return false;
44548 if(equal(id_ManagementBasedMDTallowed)) { type = 1; return true; }
44549 else if(equal(id_ManagementBasedMDTPLMNList)) { type = 2; return true; }
44550 else if(equal(id_UESidelinkAggregateMaximumBitRate)) { type = 3; return true; }
44551 else { type = 4; return true;}
44555 template<typename V> bool encode(V& v) const
44557 return v(ref_nested());
44561 template<typename V> bool decode(size_t index, V& v)
44566 case 1: type = 1; if(v(ref_nested())) { return equal(id_ManagementBasedMDTallowed);} return false;
44567 case 2: type = 2; if(v(ref_nested())) { return equal(id_ManagementBasedMDTPLMNList);} return false;
44568 case 3: type = 3; if(v(ref_nested())) { return equal(id_UESidelinkAggregateMaximumBitRate);} return false;
44569 case 4: type = 4; return v(ref_nested());
44570 ref_nested().clear();
44575 template<typename V> bool encode(size_t index, V& v) const
44577 if(index != type) {return false;} return v(ref_nested());
44584 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
44586 size_t get_index() const {return type;}
44587 bool is_unknown() const { return type == 4; }
44588 void clear() {type = 0;}
44589 void select_id_ManagementBasedMDTallowed() { set(ignore); type=1;}
44590 void select_id_ManagementBasedMDTPLMNList() { set(ignore); type=2;}
44591 void select_id_UESidelinkAggregateMaximumBitRate() { set(ignore); type=3;}
44592 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
44593 template<typename V> bool decode(V& v)
44596 if(!v(ref_nested())) return false;
44597 if(equal(ignore)) { type = 1; return true; }
44598 else if(equal(ignore)) { type = 2; return true; }
44599 else if(equal(ignore)) { type = 3; return true; }
44600 else { type = 4; return true;}
44604 template<typename V> bool encode(V& v) const
44606 return v(ref_nested());
44610 template<typename V> bool decode(size_t index, V& v)
44615 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
44616 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
44617 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
44618 case 4: type = 4; return v(ref_nested());
44619 ref_nested().clear();
44624 template<typename V> bool encode(size_t index, V& v) const
44626 if(index != type) {return false;} return v(ref_nested());
44633 struct Extension_t : asn::typefield<true>
44635 ~Extension_t() {clear();}
44636 size_t get_index() const {return type;}
44637 ManagementBasedMDTallowed& select_id_ManagementBasedMDTallowed() { return set<ManagementBasedMDTallowed>(1); }
44638 ManagementBasedMDTallowed const* get_id_ManagementBasedMDTallowed() const { return get<ManagementBasedMDTallowed>(1); }
44639 MDTPLMNList& select_id_ManagementBasedMDTPLMNList() { return set<MDTPLMNList>(2); }
44640 MDTPLMNList const* get_id_ManagementBasedMDTPLMNList() const { return get<MDTPLMNList>(2); }
44641 UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(3); }
44642 UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(3); }
44643 bool is_unknown() const { return type == 4; }
44648 case 1: var.destroy<ManagementBasedMDTallowed>(); break;
44649 case 2: var.destroy<MDTPLMNList>(); break;
44650 case 3: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
44652 type = 0; ref_nested().clear();
44654 template<typename V> static inline void enumerate(V& v)
44656 v.template operator()<ManagementBasedMDTallowed>(1);
44657 v.template operator()<MDTPLMNList>(2);
44658 v.template operator()<UESidelinkAggregateMaximumBitRate>(3);
44662 template<typename V> bool decode(size_t index, V& v)
44667 case 1: v(select_id_ManagementBasedMDTallowed()); return true;
44668 case 2: v(select_id_ManagementBasedMDTPLMNList()); return true;
44669 case 3: v(select_id_UESidelinkAggregateMaximumBitRate()); return true;
44670 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
44675 template<typename V> bool encode(size_t index, V& v) const
44677 if(index != type) return false;
44680 case 1: v(var.as<ManagementBasedMDTallowed>()); return true;
44681 case 2: v(var.as<MDTPLMNList>()); return true;
44682 case 3: v(var.as<UESidelinkAggregateMaximumBitRate>()); return true;
44688 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44689 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44692 char dummy1[sizeof(MDTPLMNList)];
44693 char dummy2[sizeof(ManagementBasedMDTallowed)];
44694 char dummy3[sizeof(UESidelinkAggregateMaximumBitRate)];
44697 asn::variant<sizeof(union_type)> var;
44701 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
44703 size_t get_index() const {return type;}
44704 bool is_unknown() const { return type == 4; }
44705 void clear() {type = 0;}
44706 void select_id_ManagementBasedMDTallowed() { set(optional); type=1;}
44707 void select_id_ManagementBasedMDTPLMNList() { set(optional); type=2;}
44708 void select_id_UESidelinkAggregateMaximumBitRate() { set(optional); type=3;}
44709 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
44710 template<typename V> bool decode(V& v)
44713 if(!v(ref_nested())) return false;
44714 if(equal(optional)) { type = 1; return true; }
44715 else if(equal(optional)) { type = 2; return true; }
44716 else if(equal(optional)) { type = 3; return true; }
44717 else { type = 4; return true;}
44721 template<typename V> bool encode(V& v) const
44723 return v(ref_nested());
44727 template<typename V> bool decode(size_t index, V& v)
44732 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
44733 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
44734 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
44735 case 4: type = 4; return v(ref_nested());
44736 ref_nested().clear();
44741 template<typename V> bool encode(size_t index, V& v) const
44743 if(index != type) {return false;} return v(ref_nested());
44753 UE-ContextInformation ::= SEQUENCE {
44754 mME-UE-S1AP-ID UE-S1AP-ID,
44755 uESecurityCapabilities UESecurityCapabilities,
44756 aS-SecurityInformation AS-SecurityInformation,
44757 uEaggregateMaximumBitRate UEAggregateMaximumBitRate,
44758 subscriberProfileIDforRFP SubscriberProfileIDforRFP OPTIONAL,
44759 e-RABs-ToBeSetup-List E-RABs-ToBeSetup-List,
44760 rRC-Context RRC-Context,
44761 handoverRestrictionList HandoverRestrictionList OPTIONAL,
44762 locationReportingInformation LocationReportingInformation OPTIONAL,
44763 iE-Extensions ProtocolExtensionContainer { {UE-ContextInformation-ExtIEs} } OPTIONAL,
44768 struct UE_ContextInformation : asn::sequence<10, 0, true, 4>
44770 static constexpr const char* name() {return "UE-ContextInformation";}
44771 using parent_t = asn::sequence<10, 0, true, 4>;
44772 struct mME_UE_S1AP_ID_t : UE_S1AP_ID
44774 static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
44775 using parent_t = UE_S1AP_ID;
44778 mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
44779 mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
44780 struct uESecurityCapabilities_t : UESecurityCapabilities
44782 static constexpr const char* name() {return "uESecurityCapabilities_t";}
44783 using parent_t = UESecurityCapabilities;
44786 uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
44787 uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
44788 struct aS_SecurityInformation_t : AS_SecurityInformation
44790 static constexpr const char* name() {return "aS_SecurityInformation_t";}
44791 using parent_t = AS_SecurityInformation;
44794 aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
44795 aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
44796 struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
44798 static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
44799 using parent_t = UEAggregateMaximumBitRate;
44802 uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
44803 uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
44804 struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
44806 static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
44807 using parent_t = SubscriberProfileIDforRFP;
44808 static constexpr bool optional = true;
44811 subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
44812 subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
44813 struct e_RABs_ToBeSetup_List_t : E_RABs_ToBeSetup_List
44815 static constexpr const char* name() {return "e_RABs_ToBeSetup_List_t";}
44816 using parent_t = E_RABs_ToBeSetup_List;
44819 e_RABs_ToBeSetup_List_t& ref_e_RABs_ToBeSetup_List() {return e_RABs_ToBeSetup_List;}
44820 e_RABs_ToBeSetup_List_t const& ref_e_RABs_ToBeSetup_List() const {return e_RABs_ToBeSetup_List;}
44821 struct rRC_Context_t : RRC_Context
44823 static constexpr const char* name() {return "rRC_Context_t";}
44824 using parent_t = RRC_Context;
44827 rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
44828 rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
44829 struct handoverRestrictionList_t : HandoverRestrictionList
44831 static constexpr const char* name() {return "handoverRestrictionList_t";}
44832 using parent_t = HandoverRestrictionList;
44833 static constexpr bool optional = true;
44836 handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
44837 handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
44838 struct locationReportingInformation_t : LocationReportingInformation
44840 static constexpr const char* name() {return "locationReportingInformation_t";}
44841 using parent_t = LocationReportingInformation;
44842 static constexpr bool optional = true;
44845 locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
44846 locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
44847 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformation_ExtIEs>
44849 static constexpr const char* name() {return "iE_Extensions_t";}
44850 using parent_t = ProtocolExtensionContainer<UE_ContextInformation_ExtIEs>;
44851 static constexpr bool optional = true;
44854 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
44855 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
44856 template<typename V> void decode(V& v)
44859 v(uESecurityCapabilities);
44860 v(aS_SecurityInformation);
44861 v(uEaggregateMaximumBitRate);
44862 v(subscriberProfileIDforRFP);
44863 v(e_RABs_ToBeSetup_List);
44865 v(handoverRestrictionList);
44866 v(locationReportingInformation);
44870 template<typename V> void encode(V& v) const
44873 v(uESecurityCapabilities);
44874 v(aS_SecurityInformation);
44875 v(uEaggregateMaximumBitRate);
44876 v(subscriberProfileIDforRFP);
44877 v(e_RABs_ToBeSetup_List);
44879 v(handoverRestrictionList);
44880 v(locationReportingInformation);
44886 mME_UE_S1AP_ID.clear();
44887 uESecurityCapabilities.clear();
44888 aS_SecurityInformation.clear();
44889 uEaggregateMaximumBitRate.clear();
44890 subscriberProfileIDforRFP.clear();
44891 e_RABs_ToBeSetup_List.clear();
44892 rRC_Context.clear();
44893 handoverRestrictionList.clear();
44894 locationReportingInformation.clear();
44895 iE_Extensions.clear();
44899 mME_UE_S1AP_ID_t mME_UE_S1AP_ID;
44900 uESecurityCapabilities_t uESecurityCapabilities;
44901 aS_SecurityInformation_t aS_SecurityInformation;
44902 uEaggregateMaximumBitRate_t uEaggregateMaximumBitRate;
44903 subscriberProfileIDforRFP_t subscriberProfileIDforRFP;
44904 e_RABs_ToBeSetup_List_t e_RABs_ToBeSetup_List;
44905 rRC_Context_t rRC_Context;
44906 handoverRestrictionList_t handoverRestrictionList;
44907 locationReportingInformation_t locationReportingInformation;
44908 iE_Extensions_t iE_Extensions;
44912 UE-ContextReferenceAtSeNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
44917 struct UE_ContextReferenceAtSeNB_ItemExtIEs
44919 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
44921 size_t get_index() const {return type;}
44922 bool is_unknown() const { return type == 1; }
44923 void clear() {type = 0;}
44924 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
44925 template<typename V> bool decode(V& v)
44928 if(!v(ref_nested())) return false;
44929 { type = 1; return true;}
44933 template<typename V> bool encode(V& v) const
44935 return v(ref_nested());
44939 template<typename V> bool decode(size_t index, V& v)
44944 case 1: type = 1; return v(ref_nested());
44945 ref_nested().clear();
44950 template<typename V> bool encode(size_t index, V& v) const
44952 if(index != type) {return false;} return v(ref_nested());
44959 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
44961 size_t get_index() const {return type;}
44962 bool is_unknown() const { return type == 1; }
44963 void clear() {type = 0;}
44964 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
44965 template<typename V> bool decode(V& v)
44968 if(!v(ref_nested())) return false;
44969 { type = 1; return true;}
44973 template<typename V> bool encode(V& v) const
44975 return v(ref_nested());
44979 template<typename V> bool decode(size_t index, V& v)
44984 case 1: type = 1; return v(ref_nested());
44985 ref_nested().clear();
44990 template<typename V> bool encode(size_t index, V& v) const
44992 if(index != type) {return false;} return v(ref_nested());
44999 struct Extension_t : asn::typefield<true>
45001 ~Extension_t() {clear();}
45002 size_t get_index() const {return type;}
45003 bool is_unknown() const { return type == 1; }
45006 type = 0; ref_nested().clear();
45008 template<typename V> static inline void enumerate(V& v)
45013 template<typename V> bool decode(size_t index, V& v)
45018 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45023 template<typename V> bool encode(size_t index, V& v) const
45025 if(index != type) return false;
45033 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45035 size_t get_index() const {return type;}
45036 bool is_unknown() const { return type == 1; }
45037 void clear() {type = 0;}
45038 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45039 template<typename V> bool decode(V& v)
45042 if(!v(ref_nested())) return false;
45043 { type = 1; return true;}
45047 template<typename V> bool encode(V& v) const
45049 return v(ref_nested());
45053 template<typename V> bool decode(size_t index, V& v)
45058 case 1: type = 1; return v(ref_nested());
45059 ref_nested().clear();
45064 template<typename V> bool encode(size_t index, V& v) const
45066 if(index != type) {return false;} return v(ref_nested());
45076 UE-ContextReferenceAtSeNB ::= SEQUENCE {
45077 source-GlobalSeNB-ID GlobalENB-ID,
45078 seNB-UE-X2AP-ID UE-X2AP-ID,
45079 seNB-UE-X2AP-ID-Extension UE-X2AP-ID-Extension,
45080 iE-Extensions ProtocolExtensionContainer { {UE-ContextReferenceAtSeNB-ItemExtIEs} } OPTIONAL,
45085 struct UE_ContextReferenceAtSeNB : asn::sequence<4, 0, true, 1>
45087 static constexpr const char* name() {return "UE-ContextReferenceAtSeNB";}
45088 using parent_t = asn::sequence<4, 0, true, 1>;
45089 struct source_GlobalSeNB_ID_t : GlobalENB_ID
45091 static constexpr const char* name() {return "source_GlobalSeNB_ID_t";}
45092 using parent_t = GlobalENB_ID;
45095 source_GlobalSeNB_ID_t& ref_source_GlobalSeNB_ID() {return source_GlobalSeNB_ID;}
45096 source_GlobalSeNB_ID_t const& ref_source_GlobalSeNB_ID() const {return source_GlobalSeNB_ID;}
45097 struct seNB_UE_X2AP_ID_t : UE_X2AP_ID
45099 static constexpr const char* name() {return "seNB_UE_X2AP_ID_t";}
45100 using parent_t = UE_X2AP_ID;
45103 seNB_UE_X2AP_ID_t& ref_seNB_UE_X2AP_ID() {return seNB_UE_X2AP_ID;}
45104 seNB_UE_X2AP_ID_t const& ref_seNB_UE_X2AP_ID() const {return seNB_UE_X2AP_ID;}
45105 struct seNB_UE_X2AP_ID_Extension_t : UE_X2AP_ID_Extension
45107 static constexpr const char* name() {return "seNB_UE_X2AP_ID_Extension_t";}
45108 using parent_t = UE_X2AP_ID_Extension;
45111 seNB_UE_X2AP_ID_Extension_t& ref_seNB_UE_X2AP_ID_Extension() {return seNB_UE_X2AP_ID_Extension;}
45112 seNB_UE_X2AP_ID_Extension_t const& ref_seNB_UE_X2AP_ID_Extension() const {return seNB_UE_X2AP_ID_Extension;}
45113 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>
45115 static constexpr const char* name() {return "iE_Extensions_t";}
45116 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>;
45117 static constexpr bool optional = true;
45120 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45121 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45122 template<typename V> void decode(V& v)
45124 v(source_GlobalSeNB_ID);
45125 v(seNB_UE_X2AP_ID);
45126 v(seNB_UE_X2AP_ID_Extension);
45130 template<typename V> void encode(V& v) const
45132 v(source_GlobalSeNB_ID);
45133 v(seNB_UE_X2AP_ID);
45134 v(seNB_UE_X2AP_ID_Extension);
45140 source_GlobalSeNB_ID.clear();
45141 seNB_UE_X2AP_ID.clear();
45142 seNB_UE_X2AP_ID_Extension.clear();
45143 iE_Extensions.clear();
45147 source_GlobalSeNB_ID_t source_GlobalSeNB_ID;
45148 seNB_UE_X2AP_ID_t seNB_UE_X2AP_ID;
45149 seNB_UE_X2AP_ID_Extension_t seNB_UE_X2AP_ID_Extension;
45150 iE_Extensions_t iE_Extensions;
45154 UE-ContextReferenceAtWT-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
45159 struct UE_ContextReferenceAtWT_ItemExtIEs
45161 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
45163 size_t get_index() const {return type;}
45164 bool is_unknown() const { return type == 1; }
45165 void clear() {type = 0;}
45166 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
45167 template<typename V> bool decode(V& v)
45170 if(!v(ref_nested())) return false;
45171 { type = 1; return true;}
45175 template<typename V> bool encode(V& v) const
45177 return v(ref_nested());
45181 template<typename V> bool decode(size_t index, V& v)
45186 case 1: type = 1; return v(ref_nested());
45187 ref_nested().clear();
45192 template<typename V> bool encode(size_t index, V& v) const
45194 if(index != type) {return false;} return v(ref_nested());
45201 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
45203 size_t get_index() const {return type;}
45204 bool is_unknown() const { return type == 1; }
45205 void clear() {type = 0;}
45206 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
45207 template<typename V> bool decode(V& v)
45210 if(!v(ref_nested())) return false;
45211 { type = 1; return true;}
45215 template<typename V> bool encode(V& v) const
45217 return v(ref_nested());
45221 template<typename V> bool decode(size_t index, V& v)
45226 case 1: type = 1; return v(ref_nested());
45227 ref_nested().clear();
45232 template<typename V> bool encode(size_t index, V& v) const
45234 if(index != type) {return false;} return v(ref_nested());
45241 struct Extension_t : asn::typefield<true>
45243 ~Extension_t() {clear();}
45244 size_t get_index() const {return type;}
45245 bool is_unknown() const { return type == 1; }
45248 type = 0; ref_nested().clear();
45250 template<typename V> static inline void enumerate(V& v)
45255 template<typename V> bool decode(size_t index, V& v)
45260 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45265 template<typename V> bool encode(size_t index, V& v) const
45267 if(index != type) return false;
45275 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45277 size_t get_index() const {return type;}
45278 bool is_unknown() const { return type == 1; }
45279 void clear() {type = 0;}
45280 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45281 template<typename V> bool decode(V& v)
45284 if(!v(ref_nested())) return false;
45285 { type = 1; return true;}
45289 template<typename V> bool encode(V& v) const
45291 return v(ref_nested());
45295 template<typename V> bool decode(size_t index, V& v)
45300 case 1: type = 1; return v(ref_nested());
45301 ref_nested().clear();
45306 template<typename V> bool encode(size_t index, V& v) const
45308 if(index != type) {return false;} return v(ref_nested());
45318 UE-ContextReferenceAtWT ::= SEQUENCE {
45320 wT-UE-XwAP-ID WT-UE-XwAP-ID,
45321 iE-Extensions ProtocolExtensionContainer { {UE-ContextReferenceAtWT-ItemExtIEs} } OPTIONAL,
45326 struct UE_ContextReferenceAtWT : asn::sequence<3, 0, true, 1>
45328 static constexpr const char* name() {return "UE-ContextReferenceAtWT";}
45329 using parent_t = asn::sequence<3, 0, true, 1>;
45330 struct wTID_t : WTID
45332 static constexpr const char* name() {return "wTID_t";}
45333 using parent_t = WTID;
45336 wTID_t& ref_wTID() {return wTID;}
45337 wTID_t const& ref_wTID() const {return wTID;}
45338 struct wT_UE_XwAP_ID_t : WT_UE_XwAP_ID
45340 static constexpr const char* name() {return "wT_UE_XwAP_ID_t";}
45341 using parent_t = WT_UE_XwAP_ID;
45344 wT_UE_XwAP_ID_t& ref_wT_UE_XwAP_ID() {return wT_UE_XwAP_ID;}
45345 wT_UE_XwAP_ID_t const& ref_wT_UE_XwAP_ID() const {return wT_UE_XwAP_ID;}
45346 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>
45348 static constexpr const char* name() {return "iE_Extensions_t";}
45349 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>;
45350 static constexpr bool optional = true;
45353 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45354 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45355 template<typename V> void decode(V& v)
45362 template<typename V> void encode(V& v) const
45372 wT_UE_XwAP_ID.clear();
45373 iE_Extensions.clear();
45378 wT_UE_XwAP_ID_t wT_UE_XwAP_ID;
45379 iE_Extensions_t iE_Extensions;
45383 UE-ContextReferenceAtSgNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
45388 struct UE_ContextReferenceAtSgNB_ItemExtIEs
45390 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
45392 size_t get_index() const {return type;}
45393 bool is_unknown() const { return type == 1; }
45394 void clear() {type = 0;}
45395 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
45396 template<typename V> bool decode(V& v)
45399 if(!v(ref_nested())) return false;
45400 { type = 1; return true;}
45404 template<typename V> bool encode(V& v) const
45406 return v(ref_nested());
45410 template<typename V> bool decode(size_t index, V& v)
45415 case 1: type = 1; return v(ref_nested());
45416 ref_nested().clear();
45421 template<typename V> bool encode(size_t index, V& v) const
45423 if(index != type) {return false;} return v(ref_nested());
45430 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
45432 size_t get_index() const {return type;}
45433 bool is_unknown() const { return type == 1; }
45434 void clear() {type = 0;}
45435 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
45436 template<typename V> bool decode(V& v)
45439 if(!v(ref_nested())) return false;
45440 { type = 1; return true;}
45444 template<typename V> bool encode(V& v) const
45446 return v(ref_nested());
45450 template<typename V> bool decode(size_t index, V& v)
45455 case 1: type = 1; return v(ref_nested());
45456 ref_nested().clear();
45461 template<typename V> bool encode(size_t index, V& v) const
45463 if(index != type) {return false;} return v(ref_nested());
45470 struct Extension_t : asn::typefield<true>
45472 ~Extension_t() {clear();}
45473 size_t get_index() const {return type;}
45474 bool is_unknown() const { return type == 1; }
45477 type = 0; ref_nested().clear();
45479 template<typename V> static inline void enumerate(V& v)
45484 template<typename V> bool decode(size_t index, V& v)
45489 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45494 template<typename V> bool encode(size_t index, V& v) const
45496 if(index != type) return false;
45504 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45506 size_t get_index() const {return type;}
45507 bool is_unknown() const { return type == 1; }
45508 void clear() {type = 0;}
45509 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45510 template<typename V> bool decode(V& v)
45513 if(!v(ref_nested())) return false;
45514 { type = 1; return true;}
45518 template<typename V> bool encode(V& v) const
45520 return v(ref_nested());
45524 template<typename V> bool decode(size_t index, V& v)
45529 case 1: type = 1; return v(ref_nested());
45530 ref_nested().clear();
45535 template<typename V> bool encode(size_t index, V& v) const
45537 if(index != type) {return false;} return v(ref_nested());
45547 UE-ContextReferenceAtSgNB ::= SEQUENCE {
45548 source-GlobalSgNB-ID GlobalGNB-ID,
45549 sgNB-UE-X2AP-ID SgNB-UE-X2AP-ID,
45550 iE-Extensions ProtocolExtensionContainer { {UE-ContextReferenceAtSgNB-ItemExtIEs} } OPTIONAL,
45555 struct UE_ContextReferenceAtSgNB : asn::sequence<3, 0, true, 1>
45557 static constexpr const char* name() {return "UE-ContextReferenceAtSgNB";}
45558 using parent_t = asn::sequence<3, 0, true, 1>;
45559 struct source_GlobalSgNB_ID_t : GlobalGNB_ID
45561 static constexpr const char* name() {return "source_GlobalSgNB_ID_t";}
45562 using parent_t = GlobalGNB_ID;
45565 source_GlobalSgNB_ID_t& ref_source_GlobalSgNB_ID() {return source_GlobalSgNB_ID;}
45566 source_GlobalSgNB_ID_t const& ref_source_GlobalSgNB_ID() const {return source_GlobalSgNB_ID;}
45567 struct sgNB_UE_X2AP_ID_t : SgNB_UE_X2AP_ID
45569 static constexpr const char* name() {return "sgNB_UE_X2AP_ID_t";}
45570 using parent_t = SgNB_UE_X2AP_ID;
45573 sgNB_UE_X2AP_ID_t& ref_sgNB_UE_X2AP_ID() {return sgNB_UE_X2AP_ID;}
45574 sgNB_UE_X2AP_ID_t const& ref_sgNB_UE_X2AP_ID() const {return sgNB_UE_X2AP_ID;}
45575 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>
45577 static constexpr const char* name() {return "iE_Extensions_t";}
45578 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>;
45579 static constexpr bool optional = true;
45582 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45583 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45584 template<typename V> void decode(V& v)
45586 v(source_GlobalSgNB_ID);
45587 v(sgNB_UE_X2AP_ID);
45591 template<typename V> void encode(V& v) const
45593 v(source_GlobalSgNB_ID);
45594 v(sgNB_UE_X2AP_ID);
45600 source_GlobalSgNB_ID.clear();
45601 sgNB_UE_X2AP_ID.clear();
45602 iE_Extensions.clear();
45606 source_GlobalSgNB_ID_t source_GlobalSgNB_ID;
45607 sgNB_UE_X2AP_ID_t sgNB_UE_X2AP_ID;
45608 iE_Extensions_t iE_Extensions;
45612 HandoverRequest-IEs X2AP-PROTOCOL-IES ::= {
45613 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
45614 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
45615 { ID id-TargetCell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory}|
45616 { ID id-GUMMEI-ID CRITICALITY reject TYPE GUMMEI PRESENCE mandatory}|
45617 { ID id-UE-ContextInformation CRITICALITY reject TYPE UE-ContextInformation PRESENCE mandatory}|
45618 { ID id-UE-HistoryInformation CRITICALITY ignore TYPE UE-HistoryInformation PRESENCE mandatory}|
45619 { ID id-TraceActivation CRITICALITY ignore TYPE TraceActivation PRESENCE optional}|
45620 { ID id-SRVCCOperationPossible CRITICALITY ignore TYPE SRVCCOperationPossible PRESENCE optional}|
45621 { ID id-CSGMembershipStatus CRITICALITY reject TYPE CSGMembershipStatus PRESENCE optional}|
45622 { ID id-MobilityInformation CRITICALITY ignore TYPE MobilityInformation PRESENCE optional}|
45623 { ID id-Masked-IMEISV CRITICALITY ignore TYPE Masked-IMEISV PRESENCE optional}|
45624 { ID id-UE-HistoryInformationFromTheUE CRITICALITY ignore TYPE UE-HistoryInformationFromTheUE PRESENCE optional}|
45625 { ID id-ExpectedUEBehaviour CRITICALITY ignore TYPE ExpectedUEBehaviour PRESENCE optional}|
45626 { ID id-ProSeAuthorized CRITICALITY ignore TYPE ProSeAuthorized PRESENCE optional}|
45627 { ID id-UE-ContextReferenceAtSeNB CRITICALITY ignore TYPE UE-ContextReferenceAtSeNB PRESENCE optional}|
45628 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
45629 { ID id-V2XServicesAuthorized CRITICALITY ignore TYPE V2XServicesAuthorized PRESENCE optional}|
45630 { ID id-UE-ContextReferenceAtWT CRITICALITY ignore TYPE UE-ContextReferenceAtWT PRESENCE optional}|
45631 { ID id-NRUESecurityCapabilities CRITICALITY ignore TYPE NRUESecurityCapabilities PRESENCE optional}|
45632 { ID id-UE-ContextReferenceAtSgNB CRITICALITY ignore TYPE UE-ContextReferenceAtSgNB PRESENCE optional}|
45633 { ID id-AerialUEsubscriptionInformation CRITICALITY ignore TYPE AerialUEsubscriptionInformation PRESENCE optional}|
45634 { ID id-Subscription-Based-UE-DifferentiationInfo CRITICALITY ignore TYPE Subscription-Based-UE-DifferentiationInfo PRESENCE optional},
45639 struct HandoverRequest_IEs
45641 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
45643 size_t get_index() const {return type;}
45644 bool is_unknown() const { return type == 23; }
45645 void clear() {type = 0;}
45646 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
45647 void select_id_Cause() { set(id_Cause); type=2;}
45648 void select_id_TargetCell_ID() { set(id_TargetCell_ID); type=3;}
45649 void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=4;}
45650 void select_id_UE_ContextInformation() { set(id_UE_ContextInformation); type=5;}
45651 void select_id_UE_HistoryInformation() { set(id_UE_HistoryInformation); type=6;}
45652 void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
45653 void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
45654 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=9;}
45655 void select_id_MobilityInformation() { set(id_MobilityInformation); type=10;}
45656 void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=11;}
45657 void select_id_UE_HistoryInformationFromTheUE() { set(id_UE_HistoryInformationFromTheUE); type=12;}
45658 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=13;}
45659 void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=14;}
45660 void select_id_UE_ContextReferenceAtSeNB() { set(id_UE_ContextReferenceAtSeNB); type=15;}
45661 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=16;}
45662 void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=17;}
45663 void select_id_UE_ContextReferenceAtWT() { set(id_UE_ContextReferenceAtWT); type=18;}
45664 void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=19;}
45665 void select_id_UE_ContextReferenceAtSgNB() { set(id_UE_ContextReferenceAtSgNB); type=20;}
45666 void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=21;}
45667 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=22;}
45668 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
45669 template<typename V> bool decode(V& v)
45672 if(!v(ref_nested())) return false;
45673 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
45674 else if(equal(id_Cause)) { type = 2; return true; }
45675 else if(equal(id_TargetCell_ID)) { type = 3; return true; }
45676 else if(equal(id_GUMMEI_ID)) { type = 4; return true; }
45677 else if(equal(id_UE_ContextInformation)) { type = 5; return true; }
45678 else if(equal(id_UE_HistoryInformation)) { type = 6; return true; }
45679 else if(equal(id_TraceActivation)) { type = 7; return true; }
45680 else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
45681 else if(equal(id_CSGMembershipStatus)) { type = 9; return true; }
45682 else if(equal(id_MobilityInformation)) { type = 10; return true; }
45683 else if(equal(id_Masked_IMEISV)) { type = 11; return true; }
45684 else if(equal(id_UE_HistoryInformationFromTheUE)) { type = 12; return true; }
45685 else if(equal(id_ExpectedUEBehaviour)) { type = 13; return true; }
45686 else if(equal(id_ProSeAuthorized)) { type = 14; return true; }
45687 else if(equal(id_UE_ContextReferenceAtSeNB)) { type = 15; return true; }
45688 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 16; return true; }
45689 else if(equal(id_V2XServicesAuthorized)) { type = 17; return true; }
45690 else if(equal(id_UE_ContextReferenceAtWT)) { type = 18; return true; }
45691 else if(equal(id_NRUESecurityCapabilities)) { type = 19; return true; }
45692 else if(equal(id_UE_ContextReferenceAtSgNB)) { type = 20; return true; }
45693 else if(equal(id_AerialUEsubscriptionInformation)) { type = 21; return true; }
45694 else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 22; return true; }
45695 else { type = 23; return true;}
45699 template<typename V> bool encode(V& v) const
45701 return v(ref_nested());
45705 template<typename V> bool decode(size_t index, V& v)
45710 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
45711 case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
45712 case 3: type = 3; if(v(ref_nested())) { return equal(id_TargetCell_ID);} return false;
45713 case 4: type = 4; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
45714 case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextInformation);} return false;
45715 case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_HistoryInformation);} return false;
45716 case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
45717 case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
45718 case 9: type = 9; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
45719 case 10: type = 10; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
45720 case 11: type = 11; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
45721 case 12: type = 12; if(v(ref_nested())) { return equal(id_UE_HistoryInformationFromTheUE);} return false;
45722 case 13: type = 13; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
45723 case 14: type = 14; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
45724 case 15: type = 15; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSeNB);} return false;
45725 case 16: type = 16; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
45726 case 17: type = 17; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
45727 case 18: type = 18; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtWT);} return false;
45728 case 19: type = 19; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
45729 case 20: type = 20; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSgNB);} return false;
45730 case 21: type = 21; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
45731 case 22: type = 22; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
45732 case 23: type = 23; return v(ref_nested());
45733 ref_nested().clear();
45738 template<typename V> bool encode(size_t index, V& v) const
45740 if(index != type) {return false;} return v(ref_nested());
45747 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
45749 size_t get_index() const {return type;}
45750 bool is_unknown() const { return type == 23; }
45751 void clear() {type = 0;}
45752 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
45753 void select_id_Cause() { set(ignore); type=2;}
45754 void select_id_TargetCell_ID() { set(reject); type=3;}
45755 void select_id_GUMMEI_ID() { set(reject); type=4;}
45756 void select_id_UE_ContextInformation() { set(reject); type=5;}
45757 void select_id_UE_HistoryInformation() { set(ignore); type=6;}
45758 void select_id_TraceActivation() { set(ignore); type=7;}
45759 void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
45760 void select_id_CSGMembershipStatus() { set(reject); type=9;}
45761 void select_id_MobilityInformation() { set(ignore); type=10;}
45762 void select_id_Masked_IMEISV() { set(ignore); type=11;}
45763 void select_id_UE_HistoryInformationFromTheUE() { set(ignore); type=12;}
45764 void select_id_ExpectedUEBehaviour() { set(ignore); type=13;}
45765 void select_id_ProSeAuthorized() { set(ignore); type=14;}
45766 void select_id_UE_ContextReferenceAtSeNB() { set(ignore); type=15;}
45767 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=16;}
45768 void select_id_V2XServicesAuthorized() { set(ignore); type=17;}
45769 void select_id_UE_ContextReferenceAtWT() { set(ignore); type=18;}
45770 void select_id_NRUESecurityCapabilities() { set(ignore); type=19;}
45771 void select_id_UE_ContextReferenceAtSgNB() { set(ignore); type=20;}
45772 void select_id_AerialUEsubscriptionInformation() { set(ignore); type=21;}
45773 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=22;}
45774 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
45775 template<typename V> bool decode(V& v)
45778 if(!v(ref_nested())) return false;
45779 if(equal(reject)) { type = 1; return true; }
45780 else if(equal(ignore)) { type = 2; return true; }
45781 else if(equal(reject)) { type = 3; return true; }
45782 else if(equal(reject)) { type = 4; return true; }
45783 else if(equal(reject)) { type = 5; return true; }
45784 else if(equal(ignore)) { type = 6; return true; }
45785 else if(equal(ignore)) { type = 7; return true; }
45786 else if(equal(ignore)) { type = 8; return true; }
45787 else if(equal(reject)) { type = 9; return true; }
45788 else if(equal(ignore)) { type = 10; return true; }
45789 else if(equal(ignore)) { type = 11; return true; }
45790 else if(equal(ignore)) { type = 12; return true; }
45791 else if(equal(ignore)) { type = 13; return true; }
45792 else if(equal(ignore)) { type = 14; return true; }
45793 else if(equal(ignore)) { type = 15; return true; }
45794 else if(equal(reject)) { type = 16; return true; }
45795 else if(equal(ignore)) { type = 17; return true; }
45796 else if(equal(ignore)) { type = 18; return true; }
45797 else if(equal(ignore)) { type = 19; return true; }
45798 else if(equal(ignore)) { type = 20; return true; }
45799 else if(equal(ignore)) { type = 21; return true; }
45800 else if(equal(ignore)) { type = 22; return true; }
45801 else { type = 23; return true;}
45805 template<typename V> bool encode(V& v) const
45807 return v(ref_nested());
45811 template<typename V> bool decode(size_t index, V& v)
45816 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
45817 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
45818 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
45819 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
45820 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
45821 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
45822 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
45823 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
45824 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
45825 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
45826 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
45827 case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
45828 case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
45829 case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
45830 case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
45831 case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
45832 case 17: type = 17; if(v(ref_nested())) { return equal(ignore);} return false;
45833 case 18: type = 18; if(v(ref_nested())) { return equal(ignore);} return false;
45834 case 19: type = 19; if(v(ref_nested())) { return equal(ignore);} return false;
45835 case 20: type = 20; if(v(ref_nested())) { return equal(ignore);} return false;
45836 case 21: type = 21; if(v(ref_nested())) { return equal(ignore);} return false;
45837 case 22: type = 22; if(v(ref_nested())) { return equal(ignore);} return false;
45838 case 23: type = 23; return v(ref_nested());
45839 ref_nested().clear();
45844 template<typename V> bool encode(size_t index, V& v) const
45846 if(index != type) {return false;} return v(ref_nested());
45853 struct Value_t : asn::typefield<true>
45855 ~Value_t() {clear();}
45856 size_t get_index() const {return type;}
45857 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
45858 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
45859 Cause& select_id_Cause() { return set<Cause>(2); }
45860 Cause const* get_id_Cause() const { return get<Cause>(2); }
45861 ECGI& select_id_TargetCell_ID() { return set<ECGI>(3); }
45862 ECGI const* get_id_TargetCell_ID() const { return get<ECGI>(3); }
45863 GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(4); }
45864 GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(4); }
45865 UE_ContextInformation& select_id_UE_ContextInformation() { return set<UE_ContextInformation>(5); }
45866 UE_ContextInformation const* get_id_UE_ContextInformation() const { return get<UE_ContextInformation>(5); }
45867 UE_HistoryInformation& select_id_UE_HistoryInformation() { return set<UE_HistoryInformation>(6); }
45868 UE_HistoryInformation const* get_id_UE_HistoryInformation() const { return get<UE_HistoryInformation>(6); }
45869 TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
45870 TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
45871 SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
45872 SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
45873 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(9); }
45874 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(9); }
45875 MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(10); }
45876 MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(10); }
45877 Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(11); }
45878 Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(11); }
45879 UE_HistoryInformationFromTheUE& select_id_UE_HistoryInformationFromTheUE() { return set<UE_HistoryInformationFromTheUE>(12); }
45880 UE_HistoryInformationFromTheUE const* get_id_UE_HistoryInformationFromTheUE() const { return get<UE_HistoryInformationFromTheUE>(12); }
45881 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(13); }
45882 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(13); }
45883 ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(14); }
45884 ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(14); }
45885 UE_ContextReferenceAtSeNB& select_id_UE_ContextReferenceAtSeNB() { return set<UE_ContextReferenceAtSeNB>(15); }
45886 UE_ContextReferenceAtSeNB const* get_id_UE_ContextReferenceAtSeNB() const { return get<UE_ContextReferenceAtSeNB>(15); }
45887 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(16); }
45888 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(16); }
45889 V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(17); }
45890 V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(17); }
45891 UE_ContextReferenceAtWT& select_id_UE_ContextReferenceAtWT() { return set<UE_ContextReferenceAtWT>(18); }
45892 UE_ContextReferenceAtWT const* get_id_UE_ContextReferenceAtWT() const { return get<UE_ContextReferenceAtWT>(18); }
45893 NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(19); }
45894 NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(19); }
45895 UE_ContextReferenceAtSgNB& select_id_UE_ContextReferenceAtSgNB() { return set<UE_ContextReferenceAtSgNB>(20); }
45896 UE_ContextReferenceAtSgNB const* get_id_UE_ContextReferenceAtSgNB() const { return get<UE_ContextReferenceAtSgNB>(20); }
45897 AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(21); }
45898 AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(21); }
45899 Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(22); }
45900 Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(22); }
45901 bool is_unknown() const { return type == 23; }
45906 case 1: var.destroy<UE_X2AP_ID>(); break;
45907 case 2: var.destroy<Cause>(); break;
45908 case 3: var.destroy<ECGI>(); break;
45909 case 4: var.destroy<GUMMEI>(); break;
45910 case 5: var.destroy<UE_ContextInformation>(); break;
45911 case 6: var.destroy<UE_HistoryInformation>(); break;
45912 case 7: var.destroy<TraceActivation>(); break;
45913 case 8: var.destroy<SRVCCOperationPossible>(); break;
45914 case 9: var.destroy<CSGMembershipStatus>(); break;
45915 case 10: var.destroy<MobilityInformation>(); break;
45916 case 11: var.destroy<Masked_IMEISV>(); break;
45917 case 12: var.destroy<UE_HistoryInformationFromTheUE>(); break;
45918 case 13: var.destroy<ExpectedUEBehaviour>(); break;
45919 case 14: var.destroy<ProSeAuthorized>(); break;
45920 case 15: var.destroy<UE_ContextReferenceAtSeNB>(); break;
45921 case 16: var.destroy<UE_X2AP_ID_Extension>(); break;
45922 case 17: var.destroy<V2XServicesAuthorized>(); break;
45923 case 18: var.destroy<UE_ContextReferenceAtWT>(); break;
45924 case 19: var.destroy<NRUESecurityCapabilities>(); break;
45925 case 20: var.destroy<UE_ContextReferenceAtSgNB>(); break;
45926 case 21: var.destroy<AerialUEsubscriptionInformation>(); break;
45927 case 22: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
45929 type = 0; ref_nested().clear();
45931 template<typename V> static inline void enumerate(V& v)
45933 v.template operator()<UE_X2AP_ID>(1);
45934 v.template operator()<Cause>(2);
45935 v.template operator()<ECGI>(3);
45936 v.template operator()<GUMMEI>(4);
45937 v.template operator()<UE_ContextInformation>(5);
45938 v.template operator()<UE_HistoryInformation>(6);
45939 v.template operator()<TraceActivation>(7);
45940 v.template operator()<SRVCCOperationPossible>(8);
45941 v.template operator()<CSGMembershipStatus>(9);
45942 v.template operator()<MobilityInformation>(10);
45943 v.template operator()<Masked_IMEISV>(11);
45944 v.template operator()<UE_HistoryInformationFromTheUE>(12);
45945 v.template operator()<ExpectedUEBehaviour>(13);
45946 v.template operator()<ProSeAuthorized>(14);
45947 v.template operator()<UE_ContextReferenceAtSeNB>(15);
45948 v.template operator()<UE_X2AP_ID_Extension>(16);
45949 v.template operator()<V2XServicesAuthorized>(17);
45950 v.template operator()<UE_ContextReferenceAtWT>(18);
45951 v.template operator()<NRUESecurityCapabilities>(19);
45952 v.template operator()<UE_ContextReferenceAtSgNB>(20);
45953 v.template operator()<AerialUEsubscriptionInformation>(21);
45954 v.template operator()<Subscription_Based_UE_DifferentiationInfo>(22);
45958 template<typename V> bool decode(size_t index, V& v)
45963 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
45964 case 2: v(select_id_Cause()); return true;
45965 case 3: v(select_id_TargetCell_ID()); return true;
45966 case 4: v(select_id_GUMMEI_ID()); return true;
45967 case 5: v(select_id_UE_ContextInformation()); return true;
45968 case 6: v(select_id_UE_HistoryInformation()); return true;
45969 case 7: v(select_id_TraceActivation()); return true;
45970 case 8: v(select_id_SRVCCOperationPossible()); return true;
45971 case 9: v(select_id_CSGMembershipStatus()); return true;
45972 case 10: v(select_id_MobilityInformation()); return true;
45973 case 11: v(select_id_Masked_IMEISV()); return true;
45974 case 12: v(select_id_UE_HistoryInformationFromTheUE()); return true;
45975 case 13: v(select_id_ExpectedUEBehaviour()); return true;
45976 case 14: v(select_id_ProSeAuthorized()); return true;
45977 case 15: v(select_id_UE_ContextReferenceAtSeNB()); return true;
45978 case 16: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
45979 case 17: v(select_id_V2XServicesAuthorized()); return true;
45980 case 18: v(select_id_UE_ContextReferenceAtWT()); return true;
45981 case 19: v(select_id_NRUESecurityCapabilities()); return true;
45982 case 20: v(select_id_UE_ContextReferenceAtSgNB()); return true;
45983 case 21: v(select_id_AerialUEsubscriptionInformation()); return true;
45984 case 22: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
45985 case 23: if(type != 23) {clear(); asn::base::set();} type = 23; return true;
45990 template<typename V> bool encode(size_t index, V& v) const
45992 if(index != type) return false;
45995 case 1: v(var.as<UE_X2AP_ID>()); return true;
45996 case 2: v(var.as<Cause>()); return true;
45997 case 3: v(var.as<ECGI>()); return true;
45998 case 4: v(var.as<GUMMEI>()); return true;
45999 case 5: v(var.as<UE_ContextInformation>()); return true;
46000 case 6: v(var.as<UE_HistoryInformation>()); return true;
46001 case 7: v(var.as<TraceActivation>()); return true;
46002 case 8: v(var.as<SRVCCOperationPossible>()); return true;
46003 case 9: v(var.as<CSGMembershipStatus>()); return true;
46004 case 10: v(var.as<MobilityInformation>()); return true;
46005 case 11: v(var.as<Masked_IMEISV>()); return true;
46006 case 12: v(var.as<UE_HistoryInformationFromTheUE>()); return true;
46007 case 13: v(var.as<ExpectedUEBehaviour>()); return true;
46008 case 14: v(var.as<ProSeAuthorized>()); return true;
46009 case 15: v(var.as<UE_ContextReferenceAtSeNB>()); return true;
46010 case 16: v(var.as<UE_X2AP_ID_Extension>()); return true;
46011 case 17: v(var.as<V2XServicesAuthorized>()); return true;
46012 case 18: v(var.as<UE_ContextReferenceAtWT>()); return true;
46013 case 19: v(var.as<NRUESecurityCapabilities>()); return true;
46014 case 20: v(var.as<UE_ContextReferenceAtSgNB>()); return true;
46015 case 21: v(var.as<AerialUEsubscriptionInformation>()); return true;
46016 case 22: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); return true;
46022 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46023 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46026 char dummy1[sizeof(AerialUEsubscriptionInformation)];
46027 char dummy2[sizeof(CSGMembershipStatus)];
46028 char dummy3[sizeof(Cause)];
46029 char dummy4[sizeof(ECGI)];
46030 char dummy5[sizeof(ExpectedUEBehaviour)];
46031 char dummy6[sizeof(GUMMEI)];
46032 char dummy7[sizeof(Masked_IMEISV)];
46033 char dummy8[sizeof(MobilityInformation)];
46034 char dummy9[sizeof(NRUESecurityCapabilities)];
46035 char dummy10[sizeof(ProSeAuthorized)];
46036 char dummy11[sizeof(SRVCCOperationPossible)];
46037 char dummy12[sizeof(Subscription_Based_UE_DifferentiationInfo)];
46038 char dummy13[sizeof(TraceActivation)];
46039 char dummy14[sizeof(UE_ContextInformation)];
46040 char dummy15[sizeof(UE_ContextReferenceAtSeNB)];
46041 char dummy16[sizeof(UE_ContextReferenceAtSgNB)];
46042 char dummy17[sizeof(UE_ContextReferenceAtWT)];
46043 char dummy18[sizeof(UE_HistoryInformation)];
46044 char dummy19[sizeof(UE_HistoryInformationFromTheUE)];
46045 char dummy20[sizeof(UE_X2AP_ID)];
46046 char dummy21[sizeof(UE_X2AP_ID_Extension)];
46047 char dummy22[sizeof(V2XServicesAuthorized)];
46050 asn::variant<sizeof(union_type)> var;
46054 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46056 size_t get_index() const {return type;}
46057 bool is_unknown() const { return type == 23; }
46058 void clear() {type = 0;}
46059 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
46060 void select_id_Cause() { set(mandatory); type=2;}
46061 void select_id_TargetCell_ID() { set(mandatory); type=3;}
46062 void select_id_GUMMEI_ID() { set(mandatory); type=4;}
46063 void select_id_UE_ContextInformation() { set(mandatory); type=5;}
46064 void select_id_UE_HistoryInformation() { set(mandatory); type=6;}
46065 void select_id_TraceActivation() { set(optional); type=7;}
46066 void select_id_SRVCCOperationPossible() { set(optional); type=8;}
46067 void select_id_CSGMembershipStatus() { set(optional); type=9;}
46068 void select_id_MobilityInformation() { set(optional); type=10;}
46069 void select_id_Masked_IMEISV() { set(optional); type=11;}
46070 void select_id_UE_HistoryInformationFromTheUE() { set(optional); type=12;}
46071 void select_id_ExpectedUEBehaviour() { set(optional); type=13;}
46072 void select_id_ProSeAuthorized() { set(optional); type=14;}
46073 void select_id_UE_ContextReferenceAtSeNB() { set(optional); type=15;}
46074 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=16;}
46075 void select_id_V2XServicesAuthorized() { set(optional); type=17;}
46076 void select_id_UE_ContextReferenceAtWT() { set(optional); type=18;}
46077 void select_id_NRUESecurityCapabilities() { set(optional); type=19;}
46078 void select_id_UE_ContextReferenceAtSgNB() { set(optional); type=20;}
46079 void select_id_AerialUEsubscriptionInformation() { set(optional); type=21;}
46080 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=22;}
46081 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46082 template<typename V> bool decode(V& v)
46085 if(!v(ref_nested())) return false;
46086 if(equal(mandatory)) { type = 1; return true; }
46087 else if(equal(mandatory)) { type = 2; return true; }
46088 else if(equal(mandatory)) { type = 3; return true; }
46089 else if(equal(mandatory)) { type = 4; return true; }
46090 else if(equal(mandatory)) { type = 5; return true; }
46091 else if(equal(mandatory)) { type = 6; return true; }
46092 else if(equal(optional)) { type = 7; return true; }
46093 else if(equal(optional)) { type = 8; return true; }
46094 else if(equal(optional)) { type = 9; return true; }
46095 else if(equal(optional)) { type = 10; return true; }
46096 else if(equal(optional)) { type = 11; return true; }
46097 else if(equal(optional)) { type = 12; return true; }
46098 else if(equal(optional)) { type = 13; return true; }
46099 else if(equal(optional)) { type = 14; return true; }
46100 else if(equal(optional)) { type = 15; return true; }
46101 else if(equal(optional)) { type = 16; return true; }
46102 else if(equal(optional)) { type = 17; return true; }
46103 else if(equal(optional)) { type = 18; return true; }
46104 else if(equal(optional)) { type = 19; return true; }
46105 else if(equal(optional)) { type = 20; return true; }
46106 else if(equal(optional)) { type = 21; return true; }
46107 else if(equal(optional)) { type = 22; return true; }
46108 else { type = 23; return true;}
46112 template<typename V> bool encode(V& v) const
46114 return v(ref_nested());
46118 template<typename V> bool decode(size_t index, V& v)
46123 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46124 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
46125 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
46126 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
46127 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
46128 case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
46129 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
46130 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
46131 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
46132 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
46133 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
46134 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
46135 case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
46136 case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
46137 case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
46138 case 16: type = 16; if(v(ref_nested())) { return equal(optional);} return false;
46139 case 17: type = 17; if(v(ref_nested())) { return equal(optional);} return false;
46140 case 18: type = 18; if(v(ref_nested())) { return equal(optional);} return false;
46141 case 19: type = 19; if(v(ref_nested())) { return equal(optional);} return false;
46142 case 20: type = 20; if(v(ref_nested())) { return equal(optional);} return false;
46143 case 21: type = 21; if(v(ref_nested())) { return equal(optional);} return false;
46144 case 22: type = 22; if(v(ref_nested())) { return equal(optional);} return false;
46145 case 23: type = 23; return v(ref_nested());
46146 ref_nested().clear();
46151 template<typename V> bool encode(size_t index, V& v) const
46153 if(index != type) {return false;} return v(ref_nested());
46163 HandoverRequest ::= SEQUENCE {
46164 protocolIEs ProtocolIE-Container {{HandoverRequest-IEs}},
46169 struct HandoverRequest : asn::sequence<1, 0, true, 0>
46171 static constexpr const char* name() {return "HandoverRequest";}
46172 using parent_t = asn::sequence<1, 0, true, 0>;
46173 struct protocolIEs_t : ProtocolIE_Container<HandoverRequest_IEs>
46175 static constexpr const char* name() {return "protocolIEs_t";}
46176 using parent_t = ProtocolIE_Container<HandoverRequest_IEs>;
46179 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46180 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46181 template<typename V> void decode(V& v)
46186 template<typename V> void encode(V& v) const
46193 protocolIEs.clear();
46197 protocolIEs_t protocolIEs;
46201 HandoverRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
46202 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
46203 { ID id-New-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
46204 { ID id-E-RABs-Admitted-List CRITICALITY ignore TYPE E-RABs-Admitted-List PRESENCE mandatory}|
46205 { ID id-E-RABs-NotAdmitted-List CRITICALITY ignore TYPE E-RAB-List PRESENCE optional}|
46206 { ID id-TargeteNBtoSource-eNBTransparentContainer CRITICALITY ignore TYPE TargeteNBtoSource-eNBTransparentContainer PRESENCE mandatory}|
46207 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
46208 { ID id-UE-ContextKeptIndicator CRITICALITY ignore TYPE UE-ContextKeptIndicator PRESENCE optional}|
46209 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
46210 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
46211 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
46212 { ID id-WT-UE-ContextKeptIndicator CRITICALITY ignore TYPE UE-ContextKeptIndicator PRESENCE optional},
46217 struct HandoverRequestAcknowledge_IEs
46219 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
46221 size_t get_index() const {return type;}
46222 bool is_unknown() const { return type == 12; }
46223 void clear() {type = 0;}
46224 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
46225 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
46226 void select_id_E_RABs_Admitted_List() { set(id_E_RABs_Admitted_List); type=3;}
46227 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
46228 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(id_TargeteNBtoSource_eNBTransparentContainer); type=5;}
46229 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
46230 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=7;}
46231 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
46232 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=9;}
46233 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=10;}
46234 void select_id_WT_UE_ContextKeptIndicator() { set(id_WT_UE_ContextKeptIndicator); type=11;}
46235 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
46236 template<typename V> bool decode(V& v)
46239 if(!v(ref_nested())) return false;
46240 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
46241 else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
46242 else if(equal(id_E_RABs_Admitted_List)) { type = 3; return true; }
46243 else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
46244 else if(equal(id_TargeteNBtoSource_eNBTransparentContainer)) { type = 5; return true; }
46245 else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
46246 else if(equal(id_UE_ContextKeptIndicator)) { type = 7; return true; }
46247 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
46248 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
46249 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
46250 else if(equal(id_WT_UE_ContextKeptIndicator)) { type = 11; return true; }
46251 else { type = 12; return true;}
46255 template<typename V> bool encode(V& v) const
46257 return v(ref_nested());
46261 template<typename V> bool decode(size_t index, V& v)
46266 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
46267 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
46268 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_List);} return false;
46269 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
46270 case 5: type = 5; if(v(ref_nested())) { return equal(id_TargeteNBtoSource_eNBTransparentContainer);} return false;
46271 case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
46272 case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
46273 case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
46274 case 9: type = 9; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
46275 case 10: type = 10; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
46276 case 11: type = 11; if(v(ref_nested())) { return equal(id_WT_UE_ContextKeptIndicator);} return false;
46277 case 12: type = 12; return v(ref_nested());
46278 ref_nested().clear();
46283 template<typename V> bool encode(size_t index, V& v) const
46285 if(index != type) {return false;} return v(ref_nested());
46292 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
46294 size_t get_index() const {return type;}
46295 bool is_unknown() const { return type == 12; }
46296 void clear() {type = 0;}
46297 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
46298 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
46299 void select_id_E_RABs_Admitted_List() { set(ignore); type=3;}
46300 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
46301 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(ignore); type=5;}
46302 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
46303 void select_id_UE_ContextKeptIndicator() { set(ignore); type=7;}
46304 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=8;}
46305 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
46306 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
46307 void select_id_WT_UE_ContextKeptIndicator() { set(ignore); type=11;}
46308 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
46309 template<typename V> bool decode(V& v)
46312 if(!v(ref_nested())) return false;
46313 if(equal(ignore)) { type = 1; return true; }
46314 else if(equal(ignore)) { type = 2; return true; }
46315 else if(equal(ignore)) { type = 3; return true; }
46316 else if(equal(ignore)) { type = 4; return true; }
46317 else if(equal(ignore)) { type = 5; return true; }
46318 else if(equal(ignore)) { type = 6; return true; }
46319 else if(equal(ignore)) { type = 7; return true; }
46320 else if(equal(ignore)) { type = 8; return true; }
46321 else if(equal(ignore)) { type = 9; return true; }
46322 else if(equal(reject)) { type = 10; return true; }
46323 else if(equal(ignore)) { type = 11; return true; }
46324 else { type = 12; return true;}
46328 template<typename V> bool encode(V& v) const
46330 return v(ref_nested());
46334 template<typename V> bool decode(size_t index, V& v)
46339 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
46340 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
46341 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
46342 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
46343 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
46344 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
46345 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
46346 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
46347 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
46348 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
46349 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
46350 case 12: type = 12; return v(ref_nested());
46351 ref_nested().clear();
46356 template<typename V> bool encode(size_t index, V& v) const
46358 if(index != type) {return false;} return v(ref_nested());
46365 struct Value_t : asn::typefield<true>
46367 ~Value_t() {clear();}
46368 size_t get_index() const {return type;}
46369 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
46370 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
46371 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
46372 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
46373 E_RABs_Admitted_List& select_id_E_RABs_Admitted_List() { return set<E_RABs_Admitted_List>(3); }
46374 E_RABs_Admitted_List const* get_id_E_RABs_Admitted_List() const { return get<E_RABs_Admitted_List>(3); }
46375 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
46376 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
46377 TargeteNBtoSource_eNBTransparentContainer& select_id_TargeteNBtoSource_eNBTransparentContainer() { return set<TargeteNBtoSource_eNBTransparentContainer>(5); }
46378 TargeteNBtoSource_eNBTransparentContainer const* get_id_TargeteNBtoSource_eNBTransparentContainer() const { return get<TargeteNBtoSource_eNBTransparentContainer>(5); }
46379 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
46380 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
46381 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(7); }
46382 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(7); }
46383 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
46384 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
46385 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
46386 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
46387 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
46388 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
46389 UE_ContextKeptIndicator& select_id_WT_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(11); }
46390 UE_ContextKeptIndicator const* get_id_WT_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(11); }
46391 bool is_unknown() const { return type == 12; }
46396 case 1: var.destroy<UE_X2AP_ID>(); break;
46397 case 2: var.destroy<UE_X2AP_ID>(); break;
46398 case 3: var.destroy<E_RABs_Admitted_List>(); break;
46399 case 4: var.destroy<E_RAB_List>(); break;
46400 case 5: var.destroy<TargeteNBtoSource_eNBTransparentContainer>(); break;
46401 case 6: var.destroy<CriticalityDiagnostics>(); break;
46402 case 7: var.destroy<UE_ContextKeptIndicator>(); break;
46403 case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
46404 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
46405 case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
46406 case 11: var.destroy<UE_ContextKeptIndicator>(); break;
46408 type = 0; ref_nested().clear();
46410 template<typename V> static inline void enumerate(V& v)
46412 v.template operator()<UE_X2AP_ID>(1);
46413 v.template operator()<UE_X2AP_ID>(2);
46414 v.template operator()<E_RABs_Admitted_List>(3);
46415 v.template operator()<E_RAB_List>(4);
46416 v.template operator()<TargeteNBtoSource_eNBTransparentContainer>(5);
46417 v.template operator()<CriticalityDiagnostics>(6);
46418 v.template operator()<UE_ContextKeptIndicator>(7);
46419 v.template operator()<UE_X2AP_ID_Extension>(8);
46420 v.template operator()<UE_X2AP_ID_Extension>(9);
46421 v.template operator()<UE_X2AP_ID_Extension>(10);
46422 v.template operator()<UE_ContextKeptIndicator>(11);
46426 template<typename V> bool decode(size_t index, V& v)
46431 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
46432 case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
46433 case 3: v(select_id_E_RABs_Admitted_List()); return true;
46434 case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
46435 case 5: v(select_id_TargeteNBtoSource_eNBTransparentContainer()); return true;
46436 case 6: v(select_id_CriticalityDiagnostics()); return true;
46437 case 7: v(select_id_UE_ContextKeptIndicator()); return true;
46438 case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
46439 case 9: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
46440 case 10: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
46441 case 11: v(select_id_WT_UE_ContextKeptIndicator()); return true;
46442 case 12: if(type != 12) {clear(); asn::base::set();} type = 12; return true;
46447 template<typename V> bool encode(size_t index, V& v) const
46449 if(index != type) return false;
46452 case 1: v(var.as<UE_X2AP_ID>()); return true;
46453 case 2: v(var.as<UE_X2AP_ID>()); return true;
46454 case 3: v(var.as<E_RABs_Admitted_List>()); return true;
46455 case 4: v(var.as<E_RAB_List>()); return true;
46456 case 5: v(var.as<TargeteNBtoSource_eNBTransparentContainer>()); return true;
46457 case 6: v(var.as<CriticalityDiagnostics>()); return true;
46458 case 7: v(var.as<UE_ContextKeptIndicator>()); return true;
46459 case 8: v(var.as<UE_X2AP_ID_Extension>()); return true;
46460 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
46461 case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
46462 case 11: v(var.as<UE_ContextKeptIndicator>()); return true;
46468 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46469 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46472 char dummy1[sizeof(CriticalityDiagnostics)];
46473 char dummy2[sizeof(E_RAB_List)];
46474 char dummy3[sizeof(E_RABs_Admitted_List)];
46475 char dummy4[sizeof(TargeteNBtoSource_eNBTransparentContainer)];
46476 char dummy5[sizeof(UE_ContextKeptIndicator)];
46477 char dummy6[sizeof(UE_X2AP_ID)];
46478 char dummy7[sizeof(UE_X2AP_ID_Extension)];
46481 asn::variant<sizeof(union_type)> var;
46485 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46487 size_t get_index() const {return type;}
46488 bool is_unknown() const { return type == 12; }
46489 void clear() {type = 0;}
46490 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
46491 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
46492 void select_id_E_RABs_Admitted_List() { set(mandatory); type=3;}
46493 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
46494 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(mandatory); type=5;}
46495 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
46496 void select_id_UE_ContextKeptIndicator() { set(optional); type=7;}
46497 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
46498 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
46499 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
46500 void select_id_WT_UE_ContextKeptIndicator() { set(optional); type=11;}
46501 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46502 template<typename V> bool decode(V& v)
46505 if(!v(ref_nested())) return false;
46506 if(equal(mandatory)) { type = 1; return true; }
46507 else if(equal(mandatory)) { type = 2; return true; }
46508 else if(equal(mandatory)) { type = 3; return true; }
46509 else if(equal(optional)) { type = 4; return true; }
46510 else if(equal(mandatory)) { type = 5; return true; }
46511 else if(equal(optional)) { type = 6; return true; }
46512 else if(equal(optional)) { type = 7; return true; }
46513 else if(equal(optional)) { type = 8; return true; }
46514 else if(equal(optional)) { type = 9; return true; }
46515 else if(equal(optional)) { type = 10; return true; }
46516 else if(equal(optional)) { type = 11; return true; }
46517 else { type = 12; return true;}
46521 template<typename V> bool encode(V& v) const
46523 return v(ref_nested());
46527 template<typename V> bool decode(size_t index, V& v)
46532 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46533 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
46534 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
46535 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
46536 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
46537 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
46538 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
46539 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
46540 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
46541 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
46542 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
46543 case 12: type = 12; return v(ref_nested());
46544 ref_nested().clear();
46549 template<typename V> bool encode(size_t index, V& v) const
46551 if(index != type) {return false;} return v(ref_nested());
46561 HandoverRequestAcknowledge ::= SEQUENCE {
46562 protocolIEs ProtocolIE-Container {{HandoverRequestAcknowledge-IEs}},
46567 struct HandoverRequestAcknowledge : asn::sequence<1, 0, true, 0>
46569 static constexpr const char* name() {return "HandoverRequestAcknowledge";}
46570 using parent_t = asn::sequence<1, 0, true, 0>;
46571 struct protocolIEs_t : ProtocolIE_Container<HandoverRequestAcknowledge_IEs>
46573 static constexpr const char* name() {return "protocolIEs_t";}
46574 using parent_t = ProtocolIE_Container<HandoverRequestAcknowledge_IEs>;
46577 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46578 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46579 template<typename V> void decode(V& v)
46584 template<typename V> void encode(V& v) const
46591 protocolIEs.clear();
46595 protocolIEs_t protocolIEs;
46599 LoadInformation-IEs X2AP-PROTOCOL-IES ::= {
46600 { ID id-CellInformation CRITICALITY ignore TYPE CellInformation-List PRESENCE mandatory} ,
46605 struct LoadInformation_IEs
46607 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
46609 size_t get_index() const {return type;}
46610 bool is_unknown() const { return type == 2; }
46611 void clear() {type = 0;}
46612 void select_id_CellInformation() { set(id_CellInformation); type=1;}
46613 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
46614 template<typename V> bool decode(V& v)
46617 if(!v(ref_nested())) return false;
46618 if(equal(id_CellInformation)) { type = 1; return true; }
46619 else { type = 2; return true;}
46623 template<typename V> bool encode(V& v) const
46625 return v(ref_nested());
46629 template<typename V> bool decode(size_t index, V& v)
46634 case 1: type = 1; if(v(ref_nested())) { return equal(id_CellInformation);} return false;
46635 case 2: type = 2; return v(ref_nested());
46636 ref_nested().clear();
46641 template<typename V> bool encode(size_t index, V& v) const
46643 if(index != type) {return false;} return v(ref_nested());
46650 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
46652 size_t get_index() const {return type;}
46653 bool is_unknown() const { return type == 2; }
46654 void clear() {type = 0;}
46655 void select_id_CellInformation() { set(ignore); type=1;}
46656 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
46657 template<typename V> bool decode(V& v)
46660 if(!v(ref_nested())) return false;
46661 if(equal(ignore)) { type = 1; return true; }
46662 else { type = 2; return true;}
46666 template<typename V> bool encode(V& v) const
46668 return v(ref_nested());
46672 template<typename V> bool decode(size_t index, V& v)
46677 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
46678 case 2: type = 2; return v(ref_nested());
46679 ref_nested().clear();
46684 template<typename V> bool encode(size_t index, V& v) const
46686 if(index != type) {return false;} return v(ref_nested());
46693 struct Value_t : asn::typefield<true>
46695 ~Value_t() {clear();}
46696 size_t get_index() const {return type;}
46697 CellInformation_List& select_id_CellInformation() { return set<CellInformation_List>(1); }
46698 CellInformation_List const* get_id_CellInformation() const { return get<CellInformation_List>(1); }
46699 bool is_unknown() const { return type == 2; }
46704 case 1: var.destroy<CellInformation_List>(); break;
46706 type = 0; ref_nested().clear();
46708 template<typename V> static inline void enumerate(V& v)
46710 v.template operator()<CellInformation_List>(1);
46714 template<typename V> bool decode(size_t index, V& v)
46719 case 1: v(select_id_CellInformation()); return true;
46720 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
46725 template<typename V> bool encode(size_t index, V& v) const
46727 if(index != type) return false;
46730 case 1: v(var.as<CellInformation_List>()); return true;
46736 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46737 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46740 char dummy1[sizeof(CellInformation_List)];
46743 asn::variant<sizeof(union_type)> var;
46747 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46749 size_t get_index() const {return type;}
46750 bool is_unknown() const { return type == 2; }
46751 void clear() {type = 0;}
46752 void select_id_CellInformation() { set(mandatory); type=1;}
46753 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46754 template<typename V> bool decode(V& v)
46757 if(!v(ref_nested())) return false;
46758 if(equal(mandatory)) { type = 1; return true; }
46759 else { type = 2; return true;}
46763 template<typename V> bool encode(V& v) const
46765 return v(ref_nested());
46769 template<typename V> bool decode(size_t index, V& v)
46774 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46775 case 2: type = 2; return v(ref_nested());
46776 ref_nested().clear();
46781 template<typename V> bool encode(size_t index, V& v) const
46783 if(index != type) {return false;} return v(ref_nested());
46793 LoadInformation ::= SEQUENCE {
46794 protocolIEs ProtocolIE-Container {{LoadInformation-IEs}},
46799 struct LoadInformation : asn::sequence<1, 0, true, 0>
46801 static constexpr const char* name() {return "LoadInformation";}
46802 using parent_t = asn::sequence<1, 0, true, 0>;
46803 struct protocolIEs_t : ProtocolIE_Container<LoadInformation_IEs>
46805 static constexpr const char* name() {return "protocolIEs_t";}
46806 using parent_t = ProtocolIE_Container<LoadInformation_IEs>;
46809 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46810 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46811 template<typename V> void decode(V& v)
46816 template<typename V> void encode(V& v) const
46823 protocolIEs.clear();
46827 protocolIEs_t protocolIEs;
46831 MeasurementInitiationResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
46836 struct MeasurementInitiationResult_Item_ExtIEs
46838 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
46840 size_t get_index() const {return type;}
46841 bool is_unknown() const { return type == 1; }
46842 void clear() {type = 0;}
46843 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
46844 template<typename V> bool decode(V& v)
46847 if(!v(ref_nested())) return false;
46848 { type = 1; return true;}
46852 template<typename V> bool encode(V& v) const
46854 return v(ref_nested());
46858 template<typename V> bool decode(size_t index, V& v)
46863 case 1: type = 1; return v(ref_nested());
46864 ref_nested().clear();
46869 template<typename V> bool encode(size_t index, V& v) const
46871 if(index != type) {return false;} return v(ref_nested());
46878 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
46880 size_t get_index() const {return type;}
46881 bool is_unknown() const { return type == 1; }
46882 void clear() {type = 0;}
46883 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
46884 template<typename V> bool decode(V& v)
46887 if(!v(ref_nested())) return false;
46888 { type = 1; return true;}
46892 template<typename V> bool encode(V& v) const
46894 return v(ref_nested());
46898 template<typename V> bool decode(size_t index, V& v)
46903 case 1: type = 1; return v(ref_nested());
46904 ref_nested().clear();
46909 template<typename V> bool encode(size_t index, V& v) const
46911 if(index != type) {return false;} return v(ref_nested());
46918 struct Extension_t : asn::typefield<true>
46920 ~Extension_t() {clear();}
46921 size_t get_index() const {return type;}
46922 bool is_unknown() const { return type == 1; }
46925 type = 0; ref_nested().clear();
46927 template<typename V> static inline void enumerate(V& v)
46932 template<typename V> bool decode(size_t index, V& v)
46937 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
46942 template<typename V> bool encode(size_t index, V& v) const
46944 if(index != type) return false;
46952 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
46954 size_t get_index() const {return type;}
46955 bool is_unknown() const { return type == 1; }
46956 void clear() {type = 0;}
46957 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
46958 template<typename V> bool decode(V& v)
46961 if(!v(ref_nested())) return false;
46962 { type = 1; return true;}
46966 template<typename V> bool encode(V& v) const
46968 return v(ref_nested());
46972 template<typename V> bool decode(size_t index, V& v)
46977 case 1: type = 1; return v(ref_nested());
46978 ref_nested().clear();
46983 template<typename V> bool encode(size_t index, V& v) const
46985 if(index != type) {return false;} return v(ref_nested());
46995 MeasurementInitiationResult-Item ::= SEQUENCE {
46997 measurementFailureCause-List MeasurementFailureCause-List OPTIONAL,
46998 iE-Extensions ProtocolExtensionContainer { {MeasurementInitiationResult-Item-ExtIEs} } OPTIONAL,
47003 struct MeasurementInitiationResult_Item : asn::sequence<3, 0, true, 2>
47005 static constexpr const char* name() {return "MeasurementInitiationResult-Item";}
47006 using parent_t = asn::sequence<3, 0, true, 2>;
47007 struct cell_ID_t : ECGI
47009 static constexpr const char* name() {return "cell_ID_t";}
47010 using parent_t = ECGI;
47013 cell_ID_t& ref_cell_ID() {return cell_ID;}
47014 cell_ID_t const& ref_cell_ID() const {return cell_ID;}
47015 struct measurementFailureCause_List_t : MeasurementFailureCause_List
47017 static constexpr const char* name() {return "measurementFailureCause_List_t";}
47018 using parent_t = MeasurementFailureCause_List;
47019 static constexpr bool optional = true;
47022 measurementFailureCause_List_t& set_measurementFailureCause_List() { measurementFailureCause_List.setpresent(true); return measurementFailureCause_List;}
47023 measurementFailureCause_List_t const* get_measurementFailureCause_List() const {return measurementFailureCause_List.is_valid() ? &measurementFailureCause_List : nullptr;}
47024 struct iE_Extensions_t : ProtocolExtensionContainer<MeasurementInitiationResult_Item_ExtIEs>
47026 static constexpr const char* name() {return "iE_Extensions_t";}
47027 using parent_t = ProtocolExtensionContainer<MeasurementInitiationResult_Item_ExtIEs>;
47028 static constexpr bool optional = true;
47031 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
47032 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
47033 template<typename V> void decode(V& v)
47036 v(measurementFailureCause_List);
47040 template<typename V> void encode(V& v) const
47043 v(measurementFailureCause_List);
47050 measurementFailureCause_List.clear();
47051 iE_Extensions.clear();
47056 measurementFailureCause_List_t measurementFailureCause_List;
47057 iE_Extensions_t iE_Extensions;
47061 MeasurementInitiationResult-ItemIEs X2AP-PROTOCOL-IES ::= {
47062 { ID id-MeasurementInitiationResult-Item CRITICALITY ignore TYPE MeasurementInitiationResult-Item PRESENCE mandatory}
47066 struct MeasurementInitiationResult_ItemIEs
47068 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
47070 size_t get_index() const {return type;}
47071 void clear() {type = 0;}
47072 void select_id_MeasurementInitiationResult_Item() { set(id_MeasurementInitiationResult_Item); type=1;}
47073 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47074 template<typename V> bool decode(V& v)
47077 if(!v(ref_nested())) return false;
47078 if(equal(id_MeasurementInitiationResult_Item)) { type = 1; return true; }
47082 template<typename V> bool encode(V& v) const
47084 return v(ref_nested());
47088 template<typename V> bool decode(size_t index, V& v)
47093 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeasurementInitiationResult_Item);} return false;
47094 ref_nested().clear();
47099 template<typename V> bool encode(size_t index, V& v) const
47101 if(index != type) {return false;} return v(ref_nested());
47108 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
47110 size_t get_index() const {return type;}
47111 void clear() {type = 0;}
47112 void select_id_MeasurementInitiationResult_Item() { set(ignore); type=1;}
47113 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47114 template<typename V> bool decode(V& v)
47117 if(!v(ref_nested())) return false;
47118 if(equal(ignore)) { type = 1; return true; }
47122 template<typename V> bool encode(V& v) const
47124 return v(ref_nested());
47128 template<typename V> bool decode(size_t index, V& v)
47133 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
47134 ref_nested().clear();
47139 template<typename V> bool encode(size_t index, V& v) const
47141 if(index != type) {return false;} return v(ref_nested());
47148 struct Value_t : asn::typefield<false>
47150 ~Value_t() {clear();}
47151 size_t get_index() const {return type;}
47152 MeasurementInitiationResult_Item& select_id_MeasurementInitiationResult_Item() { return set<MeasurementInitiationResult_Item>(1); }
47153 MeasurementInitiationResult_Item const* get_id_MeasurementInitiationResult_Item() const { return get<MeasurementInitiationResult_Item>(1); }
47158 case 1: var.destroy<MeasurementInitiationResult_Item>(); break;
47160 type = 0; ref_nested().clear();
47162 template<typename V> static inline void enumerate(V& v)
47164 v.template operator()<MeasurementInitiationResult_Item>(1);
47168 template<typename V> bool decode(size_t index, V& v)
47173 case 1: v(select_id_MeasurementInitiationResult_Item()); return true;
47178 template<typename V> bool encode(size_t index, V& v) const
47180 if(index != type) return false;
47183 case 1: v(var.as<MeasurementInitiationResult_Item>()); return true;
47189 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47190 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47193 char dummy1[sizeof(MeasurementInitiationResult_Item)];
47196 asn::variant<sizeof(union_type)> var;
47200 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
47202 size_t get_index() const {return type;}
47203 void clear() {type = 0;}
47204 void select_id_MeasurementInitiationResult_Item() { set(mandatory); type=1;}
47205 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47206 template<typename V> bool decode(V& v)
47209 if(!v(ref_nested())) return false;
47210 if(equal(mandatory)) { type = 1; return true; }
47214 template<typename V> bool encode(V& v) const
47216 return v(ref_nested());
47220 template<typename V> bool decode(size_t index, V& v)
47225 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47226 ref_nested().clear();
47231 template<typename V> bool encode(size_t index, V& v) const
47233 if(index != type) {return false;} return v(ref_nested());
47243 MeasurementInitiationResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {MeasurementInitiationResult-ItemIEs} }
47246 struct MeasurementInitiationResult_List_elm : ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>
47248 static constexpr const char* name() {return "MeasurementInitiationResult_List_elm";}
47249 using parent_t = ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>;
47252 struct MeasurementInitiationResult_List : asn::sequenceof<MeasurementInitiationResult_List_elm>
47254 static constexpr const char* name() {return "MeasurementInitiationResult-List";}
47255 using parent_t = asn::sequenceof<MeasurementInitiationResult_List_elm>;
47256 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
47260 MobilityChangeAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
47261 { ID id-ENB1-Cell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory}|
47262 { ID id-ENB2-Cell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory}|
47263 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
47268 struct MobilityChangeAcknowledge_IEs
47270 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47272 size_t get_index() const {return type;}
47273 bool is_unknown() const { return type == 4; }
47274 void clear() {type = 0;}
47275 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47276 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47277 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
47278 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47279 template<typename V> bool decode(V& v)
47282 if(!v(ref_nested())) return false;
47283 if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47284 else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47285 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
47286 else { type = 4; return true;}
47290 template<typename V> bool encode(V& v) const
47292 return v(ref_nested());
47296 template<typename V> bool decode(size_t index, V& v)
47301 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47302 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47303 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
47304 case 4: type = 4; return v(ref_nested());
47305 ref_nested().clear();
47310 template<typename V> bool encode(size_t index, V& v) const
47312 if(index != type) {return false;} return v(ref_nested());
47319 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47321 size_t get_index() const {return type;}
47322 bool is_unknown() const { return type == 4; }
47323 void clear() {type = 0;}
47324 void select_id_ENB1_Cell_ID() { set(reject); type=1;}
47325 void select_id_ENB2_Cell_ID() { set(reject); type=2;}
47326 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
47327 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47328 template<typename V> bool decode(V& v)
47331 if(!v(ref_nested())) return false;
47332 if(equal(reject)) { type = 1; return true; }
47333 else if(equal(reject)) { type = 2; return true; }
47334 else if(equal(ignore)) { type = 3; return true; }
47335 else { type = 4; return true;}
47339 template<typename V> bool encode(V& v) const
47341 return v(ref_nested());
47345 template<typename V> bool decode(size_t index, V& v)
47350 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
47351 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
47352 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47353 case 4: type = 4; return v(ref_nested());
47354 ref_nested().clear();
47359 template<typename V> bool encode(size_t index, V& v) const
47361 if(index != type) {return false;} return v(ref_nested());
47368 struct Value_t : asn::typefield<true>
47370 ~Value_t() {clear();}
47371 size_t get_index() const {return type;}
47372 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47373 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47374 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47375 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47376 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
47377 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
47378 bool is_unknown() const { return type == 4; }
47383 case 1: var.destroy<ECGI>(); break;
47384 case 2: var.destroy<ECGI>(); break;
47385 case 3: var.destroy<CriticalityDiagnostics>(); break;
47387 type = 0; ref_nested().clear();
47389 template<typename V> static inline void enumerate(V& v)
47391 v.template operator()<ECGI>(1);
47392 v.template operator()<ECGI>(2);
47393 v.template operator()<CriticalityDiagnostics>(3);
47397 template<typename V> bool decode(size_t index, V& v)
47402 case 1: v(select_id_ENB1_Cell_ID()); return true;
47403 case 2: v(select_id_ENB2_Cell_ID()); return true;
47404 case 3: v(select_id_CriticalityDiagnostics()); return true;
47405 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
47410 template<typename V> bool encode(size_t index, V& v) const
47412 if(index != type) return false;
47415 case 1: v(var.as<ECGI>()); return true;
47416 case 2: v(var.as<ECGI>()); return true;
47417 case 3: v(var.as<CriticalityDiagnostics>()); return true;
47423 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47424 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47427 char dummy1[sizeof(CriticalityDiagnostics)];
47428 char dummy2[sizeof(ECGI)];
47431 asn::variant<sizeof(union_type)> var;
47435 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
47437 size_t get_index() const {return type;}
47438 bool is_unknown() const { return type == 4; }
47439 void clear() {type = 0;}
47440 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
47441 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
47442 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
47443 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47444 template<typename V> bool decode(V& v)
47447 if(!v(ref_nested())) return false;
47448 if(equal(mandatory)) { type = 1; return true; }
47449 else if(equal(mandatory)) { type = 2; return true; }
47450 else if(equal(optional)) { type = 3; return true; }
47451 else { type = 4; return true;}
47455 template<typename V> bool encode(V& v) const
47457 return v(ref_nested());
47461 template<typename V> bool decode(size_t index, V& v)
47466 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47467 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
47468 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
47469 case 4: type = 4; return v(ref_nested());
47470 ref_nested().clear();
47475 template<typename V> bool encode(size_t index, V& v) const
47477 if(index != type) {return false;} return v(ref_nested());
47487 MobilityChangeAcknowledge ::= SEQUENCE {
47488 protocolIEs ProtocolIE-Container {{MobilityChangeAcknowledge-IEs}},
47493 struct MobilityChangeAcknowledge : asn::sequence<1, 0, true, 0>
47495 static constexpr const char* name() {return "MobilityChangeAcknowledge";}
47496 using parent_t = asn::sequence<1, 0, true, 0>;
47497 struct protocolIEs_t : ProtocolIE_Container<MobilityChangeAcknowledge_IEs>
47499 static constexpr const char* name() {return "protocolIEs_t";}
47500 using parent_t = ProtocolIE_Container<MobilityChangeAcknowledge_IEs>;
47503 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
47504 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
47505 template<typename V> void decode(V& v)
47510 template<typename V> void encode(V& v) const
47517 protocolIEs.clear();
47521 protocolIEs_t protocolIEs;
47525 MobilityChangeFailure-IEs X2AP-PROTOCOL-IES ::= {
47526 { ID id-ENB1-Cell-ID CRITICALITY ignore TYPE ECGI PRESENCE mandatory}|
47527 { ID id-ENB2-Cell-ID CRITICALITY ignore TYPE ECGI PRESENCE mandatory}|
47528 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
47529 { ID id-ENB2-Mobility-Parameters-Modification-Range CRITICALITY ignore TYPE MobilityParametersModificationRange PRESENCE optional}|
47530 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
47535 struct MobilityChangeFailure_IEs
47537 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47539 size_t get_index() const {return type;}
47540 bool is_unknown() const { return type == 6; }
47541 void clear() {type = 0;}
47542 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47543 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47544 void select_id_Cause() { set(id_Cause); type=3;}
47545 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(id_ENB2_Mobility_Parameters_Modification_Range); type=4;}
47546 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
47547 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47548 template<typename V> bool decode(V& v)
47551 if(!v(ref_nested())) return false;
47552 if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47553 else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47554 else if(equal(id_Cause)) { type = 3; return true; }
47555 else if(equal(id_ENB2_Mobility_Parameters_Modification_Range)) { type = 4; return true; }
47556 else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
47557 else { type = 6; return true;}
47561 template<typename V> bool encode(V& v) const
47563 return v(ref_nested());
47567 template<typename V> bool decode(size_t index, V& v)
47572 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47573 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47574 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
47575 case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Mobility_Parameters_Modification_Range);} return false;
47576 case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
47577 case 6: type = 6; return v(ref_nested());
47578 ref_nested().clear();
47583 template<typename V> bool encode(size_t index, V& v) const
47585 if(index != type) {return false;} return v(ref_nested());
47592 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47594 size_t get_index() const {return type;}
47595 bool is_unknown() const { return type == 6; }
47596 void clear() {type = 0;}
47597 void select_id_ENB1_Cell_ID() { set(ignore); type=1;}
47598 void select_id_ENB2_Cell_ID() { set(ignore); type=2;}
47599 void select_id_Cause() { set(ignore); type=3;}
47600 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(ignore); type=4;}
47601 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
47602 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47603 template<typename V> bool decode(V& v)
47606 if(!v(ref_nested())) return false;
47607 if(equal(ignore)) { type = 1; return true; }
47608 else if(equal(ignore)) { type = 2; return true; }
47609 else if(equal(ignore)) { type = 3; return true; }
47610 else if(equal(ignore)) { type = 4; return true; }
47611 else if(equal(ignore)) { type = 5; return true; }
47612 else { type = 6; return true;}
47616 template<typename V> bool encode(V& v) const
47618 return v(ref_nested());
47622 template<typename V> bool decode(size_t index, V& v)
47627 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
47628 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
47629 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47630 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
47631 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
47632 case 6: type = 6; return v(ref_nested());
47633 ref_nested().clear();
47638 template<typename V> bool encode(size_t index, V& v) const
47640 if(index != type) {return false;} return v(ref_nested());
47647 struct Value_t : asn::typefield<true>
47649 ~Value_t() {clear();}
47650 size_t get_index() const {return type;}
47651 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47652 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47653 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47654 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47655 Cause& select_id_Cause() { return set<Cause>(3); }
47656 Cause const* get_id_Cause() const { return get<Cause>(3); }
47657 MobilityParametersModificationRange& select_id_ENB2_Mobility_Parameters_Modification_Range() { return set<MobilityParametersModificationRange>(4); }
47658 MobilityParametersModificationRange const* get_id_ENB2_Mobility_Parameters_Modification_Range() const { return get<MobilityParametersModificationRange>(4); }
47659 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
47660 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
47661 bool is_unknown() const { return type == 6; }
47666 case 1: var.destroy<ECGI>(); break;
47667 case 2: var.destroy<ECGI>(); break;
47668 case 3: var.destroy<Cause>(); break;
47669 case 4: var.destroy<MobilityParametersModificationRange>(); break;
47670 case 5: var.destroy<CriticalityDiagnostics>(); break;
47672 type = 0; ref_nested().clear();
47674 template<typename V> static inline void enumerate(V& v)
47676 v.template operator()<ECGI>(1);
47677 v.template operator()<ECGI>(2);
47678 v.template operator()<Cause>(3);
47679 v.template operator()<MobilityParametersModificationRange>(4);
47680 v.template operator()<CriticalityDiagnostics>(5);
47684 template<typename V> bool decode(size_t index, V& v)
47689 case 1: v(select_id_ENB1_Cell_ID()); return true;
47690 case 2: v(select_id_ENB2_Cell_ID()); return true;
47691 case 3: v(select_id_Cause()); return true;
47692 case 4: v(select_id_ENB2_Mobility_Parameters_Modification_Range()); return true;
47693 case 5: v(select_id_CriticalityDiagnostics()); return true;
47694 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
47699 template<typename V> bool encode(size_t index, V& v) const
47701 if(index != type) return false;
47704 case 1: v(var.as<ECGI>()); return true;
47705 case 2: v(var.as<ECGI>()); return true;
47706 case 3: v(var.as<Cause>()); return true;
47707 case 4: v(var.as<MobilityParametersModificationRange>()); return true;
47708 case 5: v(var.as<CriticalityDiagnostics>()); return true;
47714 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47715 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47718 char dummy1[sizeof(Cause)];
47719 char dummy2[sizeof(CriticalityDiagnostics)];
47720 char dummy3[sizeof(ECGI)];
47721 char dummy4[sizeof(MobilityParametersModificationRange)];
47724 asn::variant<sizeof(union_type)> var;
47728 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
47730 size_t get_index() const {return type;}
47731 bool is_unknown() const { return type == 6; }
47732 void clear() {type = 0;}
47733 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
47734 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
47735 void select_id_Cause() { set(mandatory); type=3;}
47736 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(optional); type=4;}
47737 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
47738 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47739 template<typename V> bool decode(V& v)
47742 if(!v(ref_nested())) return false;
47743 if(equal(mandatory)) { type = 1; return true; }
47744 else if(equal(mandatory)) { type = 2; return true; }
47745 else if(equal(mandatory)) { type = 3; return true; }
47746 else if(equal(optional)) { type = 4; return true; }
47747 else if(equal(optional)) { type = 5; return true; }
47748 else { type = 6; return true;}
47752 template<typename V> bool encode(V& v) const
47754 return v(ref_nested());
47758 template<typename V> bool decode(size_t index, V& v)
47763 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47764 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
47765 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
47766 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
47767 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
47768 case 6: type = 6; return v(ref_nested());
47769 ref_nested().clear();
47774 template<typename V> bool encode(size_t index, V& v) const
47776 if(index != type) {return false;} return v(ref_nested());
47786 MobilityChangeFailure ::= SEQUENCE {
47787 protocolIEs ProtocolIE-Container {{MobilityChangeFailure-IEs}},
47792 struct MobilityChangeFailure : asn::sequence<1, 0, true, 0>
47794 static constexpr const char* name() {return "MobilityChangeFailure";}
47795 using parent_t = asn::sequence<1, 0, true, 0>;
47796 struct protocolIEs_t : ProtocolIE_Container<MobilityChangeFailure_IEs>
47798 static constexpr const char* name() {return "protocolIEs_t";}
47799 using parent_t = ProtocolIE_Container<MobilityChangeFailure_IEs>;
47802 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
47803 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
47804 template<typename V> void decode(V& v)
47809 template<typename V> void encode(V& v) const
47816 protocolIEs.clear();
47820 protocolIEs_t protocolIEs;
47824 MobilityChangeRequest-IEs X2AP-PROTOCOL-IES ::= {
47825 { ID id-ENB1-Cell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory}|
47826 { ID id-ENB2-Cell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory}|
47827 { ID id-ENB1-Mobility-Parameters CRITICALITY ignore TYPE MobilityParametersInformation PRESENCE optional}|
47828 { ID id-ENB2-Proposed-Mobility-Parameters CRITICALITY reject TYPE MobilityParametersInformation PRESENCE mandatory}|
47829 { ID id-Cause CRITICALITY reject TYPE Cause PRESENCE mandatory},
47834 struct MobilityChangeRequest_IEs
47836 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47838 size_t get_index() const {return type;}
47839 bool is_unknown() const { return type == 6; }
47840 void clear() {type = 0;}
47841 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47842 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47843 void select_id_ENB1_Mobility_Parameters() { set(id_ENB1_Mobility_Parameters); type=3;}
47844 void select_id_ENB2_Proposed_Mobility_Parameters() { set(id_ENB2_Proposed_Mobility_Parameters); type=4;}
47845 void select_id_Cause() { set(id_Cause); type=5;}
47846 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47847 template<typename V> bool decode(V& v)
47850 if(!v(ref_nested())) return false;
47851 if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47852 else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47853 else if(equal(id_ENB1_Mobility_Parameters)) { type = 3; return true; }
47854 else if(equal(id_ENB2_Proposed_Mobility_Parameters)) { type = 4; return true; }
47855 else if(equal(id_Cause)) { type = 5; return true; }
47856 else { type = 6; return true;}
47860 template<typename V> bool encode(V& v) const
47862 return v(ref_nested());
47866 template<typename V> bool decode(size_t index, V& v)
47871 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47872 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47873 case 3: type = 3; if(v(ref_nested())) { return equal(id_ENB1_Mobility_Parameters);} return false;
47874 case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Proposed_Mobility_Parameters);} return false;
47875 case 5: type = 5; if(v(ref_nested())) { return equal(id_Cause);} return false;
47876 case 6: type = 6; return v(ref_nested());
47877 ref_nested().clear();
47882 template<typename V> bool encode(size_t index, V& v) const
47884 if(index != type) {return false;} return v(ref_nested());
47891 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47893 size_t get_index() const {return type;}
47894 bool is_unknown() const { return type == 6; }
47895 void clear() {type = 0;}
47896 void select_id_ENB1_Cell_ID() { set(reject); type=1;}
47897 void select_id_ENB2_Cell_ID() { set(reject); type=2;}
47898 void select_id_ENB1_Mobility_Parameters() { set(ignore); type=3;}
47899 void select_id_ENB2_Proposed_Mobility_Parameters() { set(reject); type=4;}
47900 void select_id_Cause() { set(reject); type=5;}
47901 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47902 template<typename V> bool decode(V& v)
47905 if(!v(ref_nested())) return false;
47906 if(equal(reject)) { type = 1; return true; }
47907 else if(equal(reject)) { type = 2; return true; }
47908 else if(equal(ignore)) { type = 3; return true; }
47909 else if(equal(reject)) { type = 4; return true; }
47910 else if(equal(reject)) { type = 5; return true; }
47911 else { type = 6; return true;}
47915 template<typename V> bool encode(V& v) const
47917 return v(ref_nested());
47921 template<typename V> bool decode(size_t index, V& v)
47926 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
47927 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
47928 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47929 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
47930 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
47931 case 6: type = 6; return v(ref_nested());
47932 ref_nested().clear();
47937 template<typename V> bool encode(size_t index, V& v) const
47939 if(index != type) {return false;} return v(ref_nested());
47946 struct Value_t : asn::typefield<true>
47948 ~Value_t() {clear();}
47949 size_t get_index() const {return type;}
47950 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47951 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47952 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47953 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47954 MobilityParametersInformation& select_id_ENB1_Mobility_Parameters() { return set<MobilityParametersInformation>(3); }
47955 MobilityParametersInformation const* get_id_ENB1_Mobility_Parameters() const { return get<MobilityParametersInformation>(3); }
47956 MobilityParametersInformation& select_id_ENB2_Proposed_Mobility_Parameters() { return set<MobilityParametersInformation>(4); }
47957 MobilityParametersInformation const* get_id_ENB2_Proposed_Mobility_Parameters() const { return get<MobilityParametersInformation>(4); }
47958 Cause& select_id_Cause() { return set<Cause>(5); }
47959 Cause const* get_id_Cause() const { return get<Cause>(5); }
47960 bool is_unknown() const { return type == 6; }
47965 case 1: var.destroy<ECGI>(); break;
47966 case 2: var.destroy<ECGI>(); break;
47967 case 3: var.destroy<MobilityParametersInformation>(); break;
47968 case 4: var.destroy<MobilityParametersInformation>(); break;
47969 case 5: var.destroy<Cause>(); break;
47971 type = 0; ref_nested().clear();
47973 template<typename V> static inline void enumerate(V& v)
47975 v.template operator()<ECGI>(1);
47976 v.template operator()<ECGI>(2);
47977 v.template operator()<MobilityParametersInformation>(3);
47978 v.template operator()<MobilityParametersInformation>(4);
47979 v.template operator()<Cause>(5);
47983 template<typename V> bool decode(size_t index, V& v)
47988 case 1: v(select_id_ENB1_Cell_ID()); return true;
47989 case 2: v(select_id_ENB2_Cell_ID()); return true;
47990 case 3: v(select_id_ENB1_Mobility_Parameters()); return true;
47991 case 4: v(select_id_ENB2_Proposed_Mobility_Parameters()); return true;
47992 case 5: v(select_id_Cause()); return true;
47993 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
47998 template<typename V> bool encode(size_t index, V& v) const
48000 if(index != type) return false;
48003 case 1: v(var.as<ECGI>()); return true;
48004 case 2: v(var.as<ECGI>()); return true;
48005 case 3: v(var.as<MobilityParametersInformation>()); return true;
48006 case 4: v(var.as<MobilityParametersInformation>()); return true;
48007 case 5: v(var.as<Cause>()); return true;
48013 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
48014 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
48017 char dummy1[sizeof(Cause)];
48018 char dummy2[sizeof(ECGI)];
48019 char dummy3[sizeof(MobilityParametersInformation)];
48022 asn::variant<sizeof(union_type)> var;
48026 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
48028 size_t get_index() const {return type;}
48029 bool is_unknown() const { return type == 6; }
48030 void clear() {type = 0;}
48031 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
48032 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
48033 void select_id_ENB1_Mobility_Parameters() { set(optional); type=3;}
48034 void select_id_ENB2_Proposed_Mobility_Parameters() { set(mandatory); type=4;}
48035 void select_id_Cause() { set(mandatory); type=5;}
48036 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
48037 template<typename V> bool decode(V& v)
48040 if(!v(ref_nested())) return false;
48041 if(equal(mandatory)) { type = 1; return true; }
48042 else if(equal(mandatory)) { type = 2; return true; }
48043 else if(equal(optional)) { type = 3; return true; }
48044 else if(equal(mandatory)) { type = 4; return true; }
48045 else if(equal(mandatory)) { type = 5; return true; }
48046 else { type = 6; return true;}
48050 template<typename V> bool encode(V& v) const
48052 return v(ref_nested());
48056 template<typename V> bool decode(size_t index, V& v)
48061 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
48062 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
48063 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
48064 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
48065 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
48066 case 6: type = 6; return v(ref_nested());
48067 ref_nested().clear();
48072 template<typename V> bool encode(size_t index, V& v) const
48074 if(index != type) {return false;} return v(ref_nested());
48084 MobilityChangeRequest ::= SEQUENCE {
48085 protocolIEs ProtocolIE-Container {{MobilityChangeRequest-IEs}},
48090 struct MobilityChangeRequest : asn::sequence<1, 0, true, 0>
48092 static constexpr const char* name() {return "MobilityChangeRequest";}
48093 using parent_t = asn::sequence<1, 0, true, 0>;
48094 struct protocolIEs_t : ProtocolIE_Container<MobilityChangeRequest_IEs>
48096 static constexpr const char* name() {return "protocolIEs_t";}
48097 using parent_t = ProtocolIE_Container<MobilityChangeRequest_IEs>;
48100 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
48101 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
48102 template<typename V> void decode(V& v)
48107 template<typename V> void encode(V& v) const
48114 protocolIEs.clear();
48118 protocolIEs_t protocolIEs;
48122 PartialSuccessIndicator ::= ENUMERATED {
48123 partial-success-allowed,
48128 struct PartialSuccessIndicator : asn::enumerated<1, 0, true>
48130 static constexpr const char* name() {return "PartialSuccessIndicator";}
48131 using parent_t = asn::enumerated<1, 0, true>;
48133 partial_success_allowed
48139 PrivateMessage-IEs X2AP-PRIVATE-IES ::= {
48144 struct PrivateMessage_IEs
48146 struct id_t : asn::fixedtypefield<X2AP_PRIVATE_IES::id_t, true>
48148 size_t get_index() const {return type;}
48149 bool is_unknown() const { return type == 1; }
48150 void clear() {type = 0;}
48151 X2AP_PRIVATE_IES::id_t const& ref_value() const {return ref_nested();}
48152 template<typename V> bool decode(V& v)
48155 if(!v(ref_nested())) return false;
48156 { type = 1; return true;}
48160 template<typename V> bool encode(V& v) const
48162 return v(ref_nested());
48166 template<typename V> bool decode(size_t index, V& v)
48171 case 1: type = 1; return v(ref_nested());
48172 ref_nested().clear();
48177 template<typename V> bool encode(size_t index, V& v) const
48179 if(index != type) {return false;} return v(ref_nested());
48186 struct criticality_t : asn::fixedtypefield<X2AP_PRIVATE_IES::criticality_t, true>
48188 size_t get_index() const {return type;}
48189 bool is_unknown() const { return type == 1; }
48190 void clear() {type = 0;}
48191 X2AP_PRIVATE_IES::criticality_t const& ref_value() const {return ref_nested();}
48192 template<typename V> bool decode(V& v)
48195 if(!v(ref_nested())) return false;
48196 { type = 1; return true;}
48200 template<typename V> bool encode(V& v) const
48202 return v(ref_nested());
48206 template<typename V> bool decode(size_t index, V& v)
48211 case 1: type = 1; return v(ref_nested());
48212 ref_nested().clear();
48217 template<typename V> bool encode(size_t index, V& v) const
48219 if(index != type) {return false;} return v(ref_nested());
48226 struct Value_t : asn::typefield<true>
48228 ~Value_t() {clear();}
48229 size_t get_index() const {return type;}
48230 bool is_unknown() const { return type == 1; }
48233 type = 0; ref_nested().clear();
48235 template<typename V> static inline void enumerate(V& v)
48240 template<typename V> bool decode(size_t index, V& v)
48245 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
48250 template<typename V> bool encode(size_t index, V& v) const
48252 if(index != type) return false;
48260 struct presence_t : asn::fixedtypefield<X2AP_PRIVATE_IES::presence_t, true>
48262 size_t get_index() const {return type;}
48263 bool is_unknown() const { return type == 1; }
48264 void clear() {type = 0;}
48265 X2AP_PRIVATE_IES::presence_t const& ref_value() const {return ref_nested();}
48266 template<typename V> bool decode(V& v)
48269 if(!v(ref_nested())) return false;
48270 { type = 1; return true;}
48274 template<typename V> bool encode(V& v) const
48276 return v(ref_nested());
48280 template<typename V> bool decode(size_t index, V& v)
48285 case 1: type = 1; return v(ref_nested());
48286 ref_nested().clear();
48291 template<typename V> bool encode(size_t index, V& v) const
48293 if(index != type) {return false;} return v(ref_nested());
48303 PrivateMessage ::= SEQUENCE {
48304 privateIEs PrivateIE-Container {{PrivateMessage-IEs}},
48309 struct PrivateMessage : asn::sequence<1, 0, true, 0>
48311 static constexpr const char* name() {return "PrivateMessage";}
48312 using parent_t = asn::sequence<1, 0, true, 0>;
48313 struct privateIEs_t : PrivateIE_Container<PrivateMessage_IEs>
48315 static constexpr const char* name() {return "privateIEs_t";}
48316 using parent_t = PrivateIE_Container<PrivateMessage_IEs>;
48319 privateIEs_t& ref_privateIEs() {return privateIEs;}
48320 privateIEs_t const& ref_privateIEs() const {return privateIEs;}
48321 template<typename V> void decode(V& v)
48326 template<typename V> void encode(V& v) const
48333 privateIEs.clear();
48337 privateIEs_t privateIEs;
48341 RLFIndication-IEs X2AP-PROTOCOL-IES ::= {
48342 { ID id-FailureCellPCI CRITICALITY ignore TYPE PCI PRESENCE mandatory}|
48343 { ID id-Re-establishmentCellECGI CRITICALITY ignore TYPE ECGI PRESENCE mandatory}|
48344 { ID id-FailureCellCRNTI CRITICALITY ignore TYPE CRNTI PRESENCE mandatory}|
48345 { ID id-ShortMAC-I CRITICALITY ignore TYPE ShortMAC-I PRESENCE optional}|
48346 { ID id-UE-RLF-Report-Container CRITICALITY ignore TYPE UE-RLF-Report-Container PRESENCE optional}|
48347 { ID id-RRCConnSetupIndicator CRITICALITY reject TYPE RRCConnSetupIndicator PRESENCE optional}|
48348 { ID id-RRCConnReestabIndicator CRITICALITY ignore TYPE RRCConnReestabIndicator PRESENCE optional}|
48349 { ID id-UE-RLF-Report-Container-for-extended-bands CRITICALITY ignore TYPE UE-RLF-Report-Container-for-extended-bands PRESENCE optional},
48354 struct RLFIndication_IEs
48356 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
48358 size_t get_index() const {return type;}
48359 bool is_unknown() const { return type == 9; }
48360 void clear() {type = 0;}
48361 void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=1;}
48362 void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=2;}
48363 void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=3;}
48364 void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
48365 void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=5;}
48366 void select_id_RRCConnSetupIndicator() { set(id_RRCConnSetupIndicator); type=6;}
48367 void select_id_RRCConnReestabIndicator() { set(id_RRCConnReestabIndicator); type=7;}
48368 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=8;}
48369 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
48370 template<typename V> bool decode(V& v)
48373 if(!v(ref_nested())) return false;
48374 if(equal(id_FailureCellPCI)) { type = 1; return true; }
48375 else if(equal(id_Re_establishmentCellECGI)) { type = 2; return true; }
48376 else if(equal(id_FailureCellCRNTI)) { type = 3; return true; }
48377 else if(equal(id_ShortMAC_I)) { type = 4; return true; }
48378 else if(equal(id_UE_RLF_Report_Container)) { type = 5; return true; }
48379 else if(equal(id_RRCConnSetupIndicator)) { type = 6; return true; }
48380 else if(equal(id_RRCConnReestabIndicator)) { type = 7; return true; }
48381 else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 8; return true; }
48382 else { type = 9; return true;}
48386 template<typename V> bool encode(V& v) const
48388 return v(ref_nested());
48392 template<typename V> bool decode(size_t index, V& v)
48397 case 1: type = 1; if(v(ref_nested())) { return equal(id_FailureCellPCI);} return false;
48398 case 2: type = 2; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
48399 case 3: type = 3; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
48400 case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
48401 case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
48402 case 6: type = 6; if(v(ref_nested())) { return equal(id_RRCConnSetupIndicator);} return false;
48403 case 7: type = 7; if(v(ref_nested())) { return equal(id_RRCConnReestabIndicator);} return false;
48404 case 8: type = 8; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
48405 case 9: type = 9; return v(ref_nested());
48406 ref_nested().clear();
48411 template<typename V> bool encode(size_t index, V& v) const
48413 if(index != type) {return false;} return v(ref_nested());
48420 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
48422 size_t get_index() const {return type;}
48423 bool is_unknown() const { return type == 9; }
48424 void clear() {type = 0;}
48425 void select_id_FailureCellPCI() { set(ignore); type=1;}
48426 void select_id_Re_establishmentCellECGI() { set(ignore); type=2;}
48427 void select_id_FailureCellCRNTI() { set(ignore); type=3;}
48428 void select_id_ShortMAC_I() { set(ignore); type=4;}
48429 void select_id_UE_RLF_Report_Container() { set(ignore); type=5;}
48430 void select_id_RRCConnSetupIndicator() { set(reject); type=6;}
48431 void select_id_RRCConnReestabIndicator() { set(ignore); type=7;}
48432 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=8;}
48433 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
48434 template<typename V> bool decode(V& v)
48437 if(!v(ref_nested())) return false;
48438 if(equal(ignore)) { type = 1; return true; }
48439 else if(equal(ignore)) { type = 2; return true; }
48440 else if(equal(ignore)) { type = 3; return true; }
48441 else if(equal(ignore)) { type = 4; return true; }
48442 else if(equal(ignore)) { type = 5; return true; }
48443 else if(equal(reject)) { type = 6; return true; }
48444 else if(equal(ignore)) { type = 7; return true; }
48445 else if(equal(ignore)) { type = 8; return true; }
48446 else { type = 9; return true;}
48450 template<typename V> bool encode(V& v) const
48452 return v(ref_nested());
48456 template<typename V> bool decode(size_t index, V& v)
48461 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
48462 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
48463 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
48464 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
48465 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
48466 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
48467 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
48468 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
48469 case 9: type = 9; return v(ref_nested());
48470 ref_nested().clear();
48475 template<typename V> bool encode(size_t index, V& v) const
48477 if(index != type) {return false;} return v(ref_nested());
48484 struct Value_t : asn::typefield<true>
48486 ~Value_t() {clear();}
48487 size_t get_index() const {return type;}
48488 PCI& select_id_FailureCellPCI() { return set<PCI>(1); }
48489 PCI const* get_id_FailureCellPCI() const { return get<PCI>(1); }
48490 ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(2); }
48491 ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(2); }
48492 CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(3); }
48493 CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(3); }
48494 ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
48495 ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
48496 UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(5); }
48497 UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(5); }
48498 RRCConnSetupIndicator& select_id_RRCConnSetupIndicator() { return set<RRCConnSetupIndicator>(6); }
48499 RRCConnSetupIndicator const* get_id_RRCConnSetupIndicator() const { return get<RRCConnSetupIndicator>(6); }
48500 RRCConnReestabIndicator& select_id_RRCConnReestabIndicator() { return set<RRCConnReestabIndicator>(7); }
48501 RRCConnReestabIndicator const* get_id_RRCConnReestabIndicator() const { return get<RRCConnReestabIndicator>(7); }
48502 UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(8); }
48503 UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(8); }
48504 bool is_unknown() const { return type == 9; }
48509 case 1: var.destroy<PCI>(); break;
48510 case 2: var.destroy<ECGI>(); break;
48511 case 3: var.destroy<CRNTI>(); break;
48512 case 4: var.destroy<ShortMAC_I>(); break;
48513 case 5: var.destroy<UE_RLF_Report_Container>(); break;
48514 case 6: var.destroy<RRCConnSetupIndicator>(); break;
48515 case 7: var.destroy<RRCConnReestabIndicator>(); break;
48516 case 8: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
48518 type = 0; ref_nested().clear();
48520 template<typename V> static inline void enumerate(V& v)
48522 v.template operator()<PCI>(1);
48523 v.template operator()<ECGI>(2);
48524 v.template operator()<CRNTI>(3);
48525 v.template operator()<ShortMAC_I>(4);
48526 v.template operator()<UE_RLF_Report_Container>(5);
48527 v.template operator()<RRCConnSetupIndicator>(6);
48528 v.template operator()<RRCConnReestabIndicator>(7);
48529 v.template operator()<UE_RLF_Report_Container_for_extended_bands>(8);
48533 template<typename V> bool decode(size_t index, V& v)
48538 case 1: v(select_id_FailureCellPCI()); return true;
48539 case 2: v(select_id_Re_establishmentCellECGI()); return true;
48540 case 3: v(select_id_FailureCellCRNTI()); return true;
48541 case 4: v(select_id_ShortMAC_I()); return true;
48542 case 5: v(select_id_UE_RLF_Report_Container()); return true;
48543 case 6: v(select_id_RRCConnSetupIndicator()); return true;
48544 case 7: v(select_id_RRCConnReestabIndicator()); return true;
48545 case 8: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
48546 case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
48551 template<typename V> bool encode(size_t index, V& v) const
48553 if(index != type) return false;
48556 case 1: v(var.as<PCI>()); return true;
48557 case 2: v(var.as<ECGI>()); return true;
48558 case 3: v(var.as<CRNTI>()); return true;
48559 case 4: v(var.as<ShortMAC_I>()); return true;
48560 case 5: v(var.as<UE_RLF_Report_Container>()); return true;
48561 case 6: v(var.as<RRCConnSetupIndicator>()); return true;
48562 case 7: v(var.as<RRCConnReestabIndicator>()); return true;
48563 case 8: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); return true;
48569 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
48570 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
48573 char dummy1[sizeof(CRNTI)];
48574 char dummy2[sizeof(ECGI)];
48575 char dummy3[sizeof(PCI)];
48576 char dummy4[sizeof(RRCConnReestabIndicator)];
48577 char dummy5[sizeof(RRCConnSetupIndicator)];
48578 char dummy6[sizeof(ShortMAC_I)];
48579 char dummy7[sizeof(UE_RLF_Report_Container)];
48580 char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
48583 asn::variant<sizeof(union_type)> var;
48587 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
48589 size_t get_index() const {return type;}
48590 bool is_unknown() const { return type == 9; }
48591 void clear() {type = 0;}
48592 void select_id_FailureCellPCI() { set(mandatory); type=1;}
48593 void select_id_Re_establishmentCellECGI() { set(mandatory); type=2;}
48594 void select_id_FailureCellCRNTI() { set(mandatory); type=3;}
48595 void select_id_ShortMAC_I() { set(optional); type=4;}
48596 void select_id_UE_RLF_Report_Container() { set(optional); type=5;}
48597 void select_id_RRCConnSetupIndicator() { set(optional); type=6;}
48598 void select_id_RRCConnReestabIndicator() { set(optional); type=7;}
48599 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=8;}
48600 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
48601 template<typename V> bool decode(V& v)
48604 if(!v(ref_nested())) return false;
48605 if(equal(mandatory)) { type = 1; return true; }
48606 else if(equal(mandatory)) { type = 2; return true; }
48607 else if(equal(mandatory)) { type = 3; return true; }
48608 else if(equal(optional)) { type = 4; return true; }
48609 else if(equal(optional)) { type = 5; return true; }
48610 else if(equal(optional)) { type = 6; return true; }
48611 else if(equal(optional)) { type = 7; return true; }
48612 else if(equal(optional)) { type = 8; return true; }
48613 else { type = 9; return true;}
48617 template<typename V> bool encode(V& v) const
48619 return v(ref_nested());
48623 template<typename V> bool decode(size_t index, V& v)
48628 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
48629 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
48630 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
48631 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
48632 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
48633 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
48634 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
48635 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
48636 case 9: type = 9; return v(ref_nested());
48637 ref_nested().clear();
48642 template<typename V> bool encode(size_t index, V& v) const
48644 if(index != type) {return false;} return v(ref_nested());
48654 RLFIndication ::= SEQUENCE {
48655 protocolIEs ProtocolIE-Container {{RLFIndication-IEs}},
48660 struct RLFIndication : asn::sequence<1, 0, true, 0>
48662 static constexpr const char* name() {return "RLFIndication";}
48663 using parent_t = asn::sequence<1, 0, true, 0>;
48664 struct protocolIEs_t : ProtocolIE_Container<RLFIndication_IEs>
48666 static constexpr const char* name() {return "protocolIEs_t";}
48667 using parent_t = ProtocolIE_Container<RLFIndication_IEs>;
48670 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
48671 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
48672 template<typename V> void decode(V& v)
48677 template<typename V> void encode(V& v) const
48684 protocolIEs.clear();
48688 protocolIEs_t protocolIEs;
48692 RNL-Header-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
48697 struct RNL_Header_Item_ExtIEs
48699 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
48701 size_t get_index() const {return type;}
48702 bool is_unknown() const { return type == 1; }
48703 void clear() {type = 0;}
48704 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
48705 template<typename V> bool decode(V& v)
48708 if(!v(ref_nested())) return false;
48709 { type = 1; return true;}
48713 template<typename V> bool encode(V& v) const
48715 return v(ref_nested());
48719 template<typename V> bool decode(size_t index, V& v)
48724 case 1: type = 1; return v(ref_nested());
48725 ref_nested().clear();
48730 template<typename V> bool encode(size_t index, V& v) const
48732 if(index != type) {return false;} return v(ref_nested());
48739 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
48741 size_t get_index() const {return type;}
48742 bool is_unknown() const { return type == 1; }
48743 void clear() {type = 0;}
48744 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
48745 template<typename V> bool decode(V& v)
48748 if(!v(ref_nested())) return false;
48749 { type = 1; return true;}
48753 template<typename V> bool encode(V& v) const
48755 return v(ref_nested());
48759 template<typename V> bool decode(size_t index, V& v)
48764 case 1: type = 1; return v(ref_nested());
48765 ref_nested().clear();
48770 template<typename V> bool encode(size_t index, V& v) const
48772 if(index != type) {return false;} return v(ref_nested());
48779 struct Extension_t : asn::typefield<true>
48781 ~Extension_t() {clear();}
48782 size_t get_index() const {return type;}
48783 bool is_unknown() const { return type == 1; }
48786 type = 0; ref_nested().clear();
48788 template<typename V> static inline void enumerate(V& v)
48793 template<typename V> bool decode(size_t index, V& v)
48798 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
48803 template<typename V> bool encode(size_t index, V& v) const
48805 if(index != type) return false;
48813 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
48815 size_t get_index() const {return type;}
48816 bool is_unknown() const { return type == 1; }
48817 void clear() {type = 0;}
48818 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
48819 template<typename V> bool decode(V& v)
48822 if(!v(ref_nested())) return false;
48823 { type = 1; return true;}
48827 template<typename V> bool encode(V& v) const
48829 return v(ref_nested());
48833 template<typename V> bool decode(size_t index, V& v)
48838 case 1: type = 1; return v(ref_nested());
48839 ref_nested().clear();
48844 template<typename V> bool encode(size_t index, V& v) const
48846 if(index != type) {return false;} return v(ref_nested());
48856 RNL-Header ::= SEQUENCE {
48857 source-GlobalENB-ID GlobalENB-ID,
48858 target-GlobalENB-ID GlobalENB-ID OPTIONAL,
48859 iE-Extensions ProtocolExtensionContainer { {RNL-Header-Item-ExtIEs} } OPTIONAL,
48864 struct RNL_Header : asn::sequence<3, 0, true, 2>
48866 static constexpr const char* name() {return "RNL-Header";}
48867 using parent_t = asn::sequence<3, 0, true, 2>;
48868 struct source_GlobalENB_ID_t : GlobalENB_ID
48870 static constexpr const char* name() {return "source_GlobalENB_ID_t";}
48871 using parent_t = GlobalENB_ID;
48874 source_GlobalENB_ID_t& ref_source_GlobalENB_ID() {return source_GlobalENB_ID;}
48875 source_GlobalENB_ID_t const& ref_source_GlobalENB_ID() const {return source_GlobalENB_ID;}
48876 struct target_GlobalENB_ID_t : GlobalENB_ID
48878 static constexpr const char* name() {return "target_GlobalENB_ID_t";}
48879 using parent_t = GlobalENB_ID;
48880 static constexpr bool optional = true;
48883 target_GlobalENB_ID_t& set_target_GlobalENB_ID() { target_GlobalENB_ID.setpresent(true); return target_GlobalENB_ID;}
48884 target_GlobalENB_ID_t const* get_target_GlobalENB_ID() const {return target_GlobalENB_ID.is_valid() ? &target_GlobalENB_ID : nullptr;}
48885 struct iE_Extensions_t : ProtocolExtensionContainer<RNL_Header_Item_ExtIEs>
48887 static constexpr const char* name() {return "iE_Extensions_t";}
48888 using parent_t = ProtocolExtensionContainer<RNL_Header_Item_ExtIEs>;
48889 static constexpr bool optional = true;
48892 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
48893 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
48894 template<typename V> void decode(V& v)
48896 v(source_GlobalENB_ID);
48897 v(target_GlobalENB_ID);
48901 template<typename V> void encode(V& v) const
48903 v(source_GlobalENB_ID);
48904 v(target_GlobalENB_ID);
48910 source_GlobalENB_ID.clear();
48911 target_GlobalENB_ID.clear();
48912 iE_Extensions.clear();
48916 source_GlobalENB_ID_t source_GlobalENB_ID;
48917 target_GlobalENB_ID_t target_GlobalENB_ID;
48918 iE_Extensions_t iE_Extensions;
48922 RRCTransfer-IEs X2AP-PROTOCOL-IES ::= {
48923 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
48924 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
48925 { ID id-SplitSRB CRITICALITY reject TYPE SplitSRB PRESENCE optional}|
48926 { ID id-UENRMeasurement CRITICALITY reject TYPE UENRMeasurement PRESENCE optional}|
48927 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
48932 struct RRCTransfer_IEs
48934 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
48936 size_t get_index() const {return type;}
48937 bool is_unknown() const { return type == 6; }
48938 void clear() {type = 0;}
48939 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
48940 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
48941 void select_id_SplitSRB() { set(id_SplitSRB); type=3;}
48942 void select_id_UENRMeasurement() { set(id_UENRMeasurement); type=4;}
48943 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
48944 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
48945 template<typename V> bool decode(V& v)
48948 if(!v(ref_nested())) return false;
48949 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
48950 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
48951 else if(equal(id_SplitSRB)) { type = 3; return true; }
48952 else if(equal(id_UENRMeasurement)) { type = 4; return true; }
48953 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
48954 else { type = 6; return true;}
48958 template<typename V> bool encode(V& v) const
48960 return v(ref_nested());
48964 template<typename V> bool decode(size_t index, V& v)
48969 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
48970 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
48971 case 3: type = 3; if(v(ref_nested())) { return equal(id_SplitSRB);} return false;
48972 case 4: type = 4; if(v(ref_nested())) { return equal(id_UENRMeasurement);} return false;
48973 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
48974 case 6: type = 6; return v(ref_nested());
48975 ref_nested().clear();
48980 template<typename V> bool encode(size_t index, V& v) const
48982 if(index != type) {return false;} return v(ref_nested());
48989 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
48991 size_t get_index() const {return type;}
48992 bool is_unknown() const { return type == 6; }
48993 void clear() {type = 0;}
48994 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
48995 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
48996 void select_id_SplitSRB() { set(reject); type=3;}
48997 void select_id_UENRMeasurement() { set(reject); type=4;}
48998 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
48999 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49000 template<typename V> bool decode(V& v)
49003 if(!v(ref_nested())) return false;
49004 if(equal(reject)) { type = 1; return true; }
49005 else if(equal(reject)) { type = 2; return true; }
49006 else if(equal(reject)) { type = 3; return true; }
49007 else if(equal(reject)) { type = 4; return true; }
49008 else if(equal(reject)) { type = 5; return true; }
49009 else { type = 6; return true;}
49013 template<typename V> bool encode(V& v) const
49015 return v(ref_nested());
49019 template<typename V> bool decode(size_t index, V& v)
49024 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
49025 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
49026 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
49027 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
49028 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
49029 case 6: type = 6; return v(ref_nested());
49030 ref_nested().clear();
49035 template<typename V> bool encode(size_t index, V& v) const
49037 if(index != type) {return false;} return v(ref_nested());
49044 struct Value_t : asn::typefield<true>
49046 ~Value_t() {clear();}
49047 size_t get_index() const {return type;}
49048 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
49049 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
49050 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
49051 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
49052 SplitSRB& select_id_SplitSRB() { return set<SplitSRB>(3); }
49053 SplitSRB const* get_id_SplitSRB() const { return get<SplitSRB>(3); }
49054 UENRMeasurement& select_id_UENRMeasurement() { return set<UENRMeasurement>(4); }
49055 UENRMeasurement const* get_id_UENRMeasurement() const { return get<UENRMeasurement>(4); }
49056 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
49057 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
49058 bool is_unknown() const { return type == 6; }
49063 case 1: var.destroy<UE_X2AP_ID>(); break;
49064 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
49065 case 3: var.destroy<SplitSRB>(); break;
49066 case 4: var.destroy<UENRMeasurement>(); break;
49067 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
49069 type = 0; ref_nested().clear();
49071 template<typename V> static inline void enumerate(V& v)
49073 v.template operator()<UE_X2AP_ID>(1);
49074 v.template operator()<SgNB_UE_X2AP_ID>(2);
49075 v.template operator()<SplitSRB>(3);
49076 v.template operator()<UENRMeasurement>(4);
49077 v.template operator()<UE_X2AP_ID_Extension>(5);
49081 template<typename V> bool decode(size_t index, V& v)
49086 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
49087 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
49088 case 3: v(select_id_SplitSRB()); return true;
49089 case 4: v(select_id_UENRMeasurement()); return true;
49090 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
49091 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
49096 template<typename V> bool encode(size_t index, V& v) const
49098 if(index != type) return false;
49101 case 1: v(var.as<UE_X2AP_ID>()); return true;
49102 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
49103 case 3: v(var.as<SplitSRB>()); return true;
49104 case 4: v(var.as<UENRMeasurement>()); return true;
49105 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
49111 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49112 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49115 char dummy1[sizeof(SgNB_UE_X2AP_ID)];
49116 char dummy2[sizeof(SplitSRB)];
49117 char dummy3[sizeof(UENRMeasurement)];
49118 char dummy4[sizeof(UE_X2AP_ID)];
49119 char dummy5[sizeof(UE_X2AP_ID_Extension)];
49122 asn::variant<sizeof(union_type)> var;
49126 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49128 size_t get_index() const {return type;}
49129 bool is_unknown() const { return type == 6; }
49130 void clear() {type = 0;}
49131 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
49132 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
49133 void select_id_SplitSRB() { set(optional); type=3;}
49134 void select_id_UENRMeasurement() { set(optional); type=4;}
49135 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
49136 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49137 template<typename V> bool decode(V& v)
49140 if(!v(ref_nested())) return false;
49141 if(equal(mandatory)) { type = 1; return true; }
49142 else if(equal(mandatory)) { type = 2; return true; }
49143 else if(equal(optional)) { type = 3; return true; }
49144 else if(equal(optional)) { type = 4; return true; }
49145 else if(equal(optional)) { type = 5; return true; }
49146 else { type = 6; return true;}
49150 template<typename V> bool encode(V& v) const
49152 return v(ref_nested());
49156 template<typename V> bool decode(size_t index, V& v)
49161 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49162 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
49163 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
49164 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
49165 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
49166 case 6: type = 6; return v(ref_nested());
49167 ref_nested().clear();
49172 template<typename V> bool encode(size_t index, V& v) const
49174 if(index != type) {return false;} return v(ref_nested());
49184 RRCTransfer ::= SEQUENCE {
49185 protocolIEs ProtocolIE-Container {{RRCTransfer-IEs}},
49190 struct RRCTransfer : asn::sequence<1, 0, true, 0>
49192 static constexpr const char* name() {return "RRCTransfer";}
49193 using parent_t = asn::sequence<1, 0, true, 0>;
49194 struct protocolIEs_t : ProtocolIE_Container<RRCTransfer_IEs>
49196 static constexpr const char* name() {return "protocolIEs_t";}
49197 using parent_t = ProtocolIE_Container<RRCTransfer_IEs>;
49200 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49201 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49202 template<typename V> void decode(V& v)
49207 template<typename V> void encode(V& v) const
49214 protocolIEs.clear();
49218 protocolIEs_t protocolIEs;
49222 ReportingPeriodicity ::= ENUMERATED {
49231 struct ReportingPeriodicity : asn::enumerated<4, 0, true>
49233 static constexpr const char* name() {return "ReportingPeriodicity";}
49234 using parent_t = asn::enumerated<4, 0, true>;
49245 ResetRequest-IEs X2AP-PROTOCOL-IES ::= {
49246 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory},
49251 struct ResetRequest_IEs
49253 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49255 size_t get_index() const {return type;}
49256 bool is_unknown() const { return type == 2; }
49257 void clear() {type = 0;}
49258 void select_id_Cause() { set(id_Cause); type=1;}
49259 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49260 template<typename V> bool decode(V& v)
49263 if(!v(ref_nested())) return false;
49264 if(equal(id_Cause)) { type = 1; return true; }
49265 else { type = 2; return true;}
49269 template<typename V> bool encode(V& v) const
49271 return v(ref_nested());
49275 template<typename V> bool decode(size_t index, V& v)
49280 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
49281 case 2: type = 2; return v(ref_nested());
49282 ref_nested().clear();
49287 template<typename V> bool encode(size_t index, V& v) const
49289 if(index != type) {return false;} return v(ref_nested());
49296 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49298 size_t get_index() const {return type;}
49299 bool is_unknown() const { return type == 2; }
49300 void clear() {type = 0;}
49301 void select_id_Cause() { set(ignore); type=1;}
49302 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49303 template<typename V> bool decode(V& v)
49306 if(!v(ref_nested())) return false;
49307 if(equal(ignore)) { type = 1; return true; }
49308 else { type = 2; return true;}
49312 template<typename V> bool encode(V& v) const
49314 return v(ref_nested());
49318 template<typename V> bool decode(size_t index, V& v)
49323 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
49324 case 2: type = 2; return v(ref_nested());
49325 ref_nested().clear();
49330 template<typename V> bool encode(size_t index, V& v) const
49332 if(index != type) {return false;} return v(ref_nested());
49339 struct Value_t : asn::typefield<true>
49341 ~Value_t() {clear();}
49342 size_t get_index() const {return type;}
49343 Cause& select_id_Cause() { return set<Cause>(1); }
49344 Cause const* get_id_Cause() const { return get<Cause>(1); }
49345 bool is_unknown() const { return type == 2; }
49350 case 1: var.destroy<Cause>(); break;
49352 type = 0; ref_nested().clear();
49354 template<typename V> static inline void enumerate(V& v)
49356 v.template operator()<Cause>(1);
49360 template<typename V> bool decode(size_t index, V& v)
49365 case 1: v(select_id_Cause()); return true;
49366 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
49371 template<typename V> bool encode(size_t index, V& v) const
49373 if(index != type) return false;
49376 case 1: v(var.as<Cause>()); return true;
49382 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49383 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49386 char dummy1[sizeof(Cause)];
49389 asn::variant<sizeof(union_type)> var;
49393 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49395 size_t get_index() const {return type;}
49396 bool is_unknown() const { return type == 2; }
49397 void clear() {type = 0;}
49398 void select_id_Cause() { set(mandatory); type=1;}
49399 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49400 template<typename V> bool decode(V& v)
49403 if(!v(ref_nested())) return false;
49404 if(equal(mandatory)) { type = 1; return true; }
49405 else { type = 2; return true;}
49409 template<typename V> bool encode(V& v) const
49411 return v(ref_nested());
49415 template<typename V> bool decode(size_t index, V& v)
49420 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49421 case 2: type = 2; return v(ref_nested());
49422 ref_nested().clear();
49427 template<typename V> bool encode(size_t index, V& v) const
49429 if(index != type) {return false;} return v(ref_nested());
49439 ResetRequest ::= SEQUENCE {
49440 protocolIEs ProtocolIE-Container {{ResetRequest-IEs}},
49445 struct ResetRequest : asn::sequence<1, 0, true, 0>
49447 static constexpr const char* name() {return "ResetRequest";}
49448 using parent_t = asn::sequence<1, 0, true, 0>;
49449 struct protocolIEs_t : ProtocolIE_Container<ResetRequest_IEs>
49451 static constexpr const char* name() {return "protocolIEs_t";}
49452 using parent_t = ProtocolIE_Container<ResetRequest_IEs>;
49455 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49456 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49457 template<typename V> void decode(V& v)
49462 template<typename V> void encode(V& v) const
49469 protocolIEs.clear();
49473 protocolIEs_t protocolIEs;
49477 ResetResponse-IEs X2AP-PROTOCOL-IES ::= {
49478 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional },
49483 struct ResetResponse_IEs
49485 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49487 size_t get_index() const {return type;}
49488 bool is_unknown() const { return type == 2; }
49489 void clear() {type = 0;}
49490 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=1;}
49491 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49492 template<typename V> bool decode(V& v)
49495 if(!v(ref_nested())) return false;
49496 if(equal(id_CriticalityDiagnostics)) { type = 1; return true; }
49497 else { type = 2; return true;}
49501 template<typename V> bool encode(V& v) const
49503 return v(ref_nested());
49507 template<typename V> bool decode(size_t index, V& v)
49512 case 1: type = 1; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
49513 case 2: type = 2; return v(ref_nested());
49514 ref_nested().clear();
49519 template<typename V> bool encode(size_t index, V& v) const
49521 if(index != type) {return false;} return v(ref_nested());
49528 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49530 size_t get_index() const {return type;}
49531 bool is_unknown() const { return type == 2; }
49532 void clear() {type = 0;}
49533 void select_id_CriticalityDiagnostics() { set(ignore); type=1;}
49534 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49535 template<typename V> bool decode(V& v)
49538 if(!v(ref_nested())) return false;
49539 if(equal(ignore)) { type = 1; return true; }
49540 else { type = 2; return true;}
49544 template<typename V> bool encode(V& v) const
49546 return v(ref_nested());
49550 template<typename V> bool decode(size_t index, V& v)
49555 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
49556 case 2: type = 2; return v(ref_nested());
49557 ref_nested().clear();
49562 template<typename V> bool encode(size_t index, V& v) const
49564 if(index != type) {return false;} return v(ref_nested());
49571 struct Value_t : asn::typefield<true>
49573 ~Value_t() {clear();}
49574 size_t get_index() const {return type;}
49575 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
49576 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
49577 bool is_unknown() const { return type == 2; }
49582 case 1: var.destroy<CriticalityDiagnostics>(); break;
49584 type = 0; ref_nested().clear();
49586 template<typename V> static inline void enumerate(V& v)
49588 v.template operator()<CriticalityDiagnostics>(1);
49592 template<typename V> bool decode(size_t index, V& v)
49597 case 1: v(select_id_CriticalityDiagnostics()); return true;
49598 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
49603 template<typename V> bool encode(size_t index, V& v) const
49605 if(index != type) return false;
49608 case 1: v(var.as<CriticalityDiagnostics>()); return true;
49614 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49615 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49618 char dummy1[sizeof(CriticalityDiagnostics)];
49621 asn::variant<sizeof(union_type)> var;
49625 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49627 size_t get_index() const {return type;}
49628 bool is_unknown() const { return type == 2; }
49629 void clear() {type = 0;}
49630 void select_id_CriticalityDiagnostics() { set(optional); type=1;}
49631 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49632 template<typename V> bool decode(V& v)
49635 if(!v(ref_nested())) return false;
49636 if(equal(optional)) { type = 1; return true; }
49637 else { type = 2; return true;}
49641 template<typename V> bool encode(V& v) const
49643 return v(ref_nested());
49647 template<typename V> bool decode(size_t index, V& v)
49652 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
49653 case 2: type = 2; return v(ref_nested());
49654 ref_nested().clear();
49659 template<typename V> bool encode(size_t index, V& v) const
49661 if(index != type) {return false;} return v(ref_nested());
49671 ResetResponse ::= SEQUENCE {
49672 protocolIEs ProtocolIE-Container {{ResetResponse-IEs}},
49677 struct ResetResponse : asn::sequence<1, 0, true, 0>
49679 static constexpr const char* name() {return "ResetResponse";}
49680 using parent_t = asn::sequence<1, 0, true, 0>;
49681 struct protocolIEs_t : ProtocolIE_Container<ResetResponse_IEs>
49683 static constexpr const char* name() {return "protocolIEs_t";}
49684 using parent_t = ProtocolIE_Container<ResetResponse_IEs>;
49687 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49688 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49689 template<typename V> void decode(V& v)
49694 template<typename V> void encode(V& v) const
49701 protocolIEs.clear();
49705 protocolIEs_t protocolIEs;
49709 ResourceStatusFailure-IEs X2AP-PROTOCOL-IES ::= {
49710 { ID id-ENB1-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
49711 { ID id-ENB2-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
49712 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
49713 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
49714 { ID id-CompleteFailureCauseInformation-List CRITICALITY ignore TYPE CompleteFailureCauseInformation-List PRESENCE optional},
49719 struct ResourceStatusFailure_IEs
49721 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49723 size_t get_index() const {return type;}
49724 bool is_unknown() const { return type == 6; }
49725 void clear() {type = 0;}
49726 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
49727 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
49728 void select_id_Cause() { set(id_Cause); type=3;}
49729 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
49730 void select_id_CompleteFailureCauseInformation_List() { set(id_CompleteFailureCauseInformation_List); type=5;}
49731 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49732 template<typename V> bool decode(V& v)
49735 if(!v(ref_nested())) return false;
49736 if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
49737 else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
49738 else if(equal(id_Cause)) { type = 3; return true; }
49739 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
49740 else if(equal(id_CompleteFailureCauseInformation_List)) { type = 5; return true; }
49741 else { type = 6; return true;}
49745 template<typename V> bool encode(V& v) const
49747 return v(ref_nested());
49751 template<typename V> bool decode(size_t index, V& v)
49756 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
49757 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
49758 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
49759 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
49760 case 5: type = 5; if(v(ref_nested())) { return equal(id_CompleteFailureCauseInformation_List);} return false;
49761 case 6: type = 6; return v(ref_nested());
49762 ref_nested().clear();
49767 template<typename V> bool encode(size_t index, V& v) const
49769 if(index != type) {return false;} return v(ref_nested());
49776 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49778 size_t get_index() const {return type;}
49779 bool is_unknown() const { return type == 6; }
49780 void clear() {type = 0;}
49781 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
49782 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
49783 void select_id_Cause() { set(ignore); type=3;}
49784 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
49785 void select_id_CompleteFailureCauseInformation_List() { set(ignore); type=5;}
49786 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49787 template<typename V> bool decode(V& v)
49790 if(!v(ref_nested())) return false;
49791 if(equal(reject)) { type = 1; return true; }
49792 else if(equal(reject)) { type = 2; return true; }
49793 else if(equal(ignore)) { type = 3; return true; }
49794 else if(equal(ignore)) { type = 4; return true; }
49795 else if(equal(ignore)) { type = 5; return true; }
49796 else { type = 6; return true;}
49800 template<typename V> bool encode(V& v) const
49802 return v(ref_nested());
49806 template<typename V> bool decode(size_t index, V& v)
49811 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
49812 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
49813 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
49814 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
49815 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
49816 case 6: type = 6; return v(ref_nested());
49817 ref_nested().clear();
49822 template<typename V> bool encode(size_t index, V& v) const
49824 if(index != type) {return false;} return v(ref_nested());
49831 struct Value_t : asn::typefield<true>
49833 ~Value_t() {clear();}
49834 size_t get_index() const {return type;}
49835 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
49836 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
49837 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
49838 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
49839 Cause& select_id_Cause() { return set<Cause>(3); }
49840 Cause const* get_id_Cause() const { return get<Cause>(3); }
49841 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
49842 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
49843 CompleteFailureCauseInformation_List& select_id_CompleteFailureCauseInformation_List() { return set<CompleteFailureCauseInformation_List>(5); }
49844 CompleteFailureCauseInformation_List const* get_id_CompleteFailureCauseInformation_List() const { return get<CompleteFailureCauseInformation_List>(5); }
49845 bool is_unknown() const { return type == 6; }
49850 case 1: var.destroy<Measurement_ID>(); break;
49851 case 2: var.destroy<Measurement_ID>(); break;
49852 case 3: var.destroy<Cause>(); break;
49853 case 4: var.destroy<CriticalityDiagnostics>(); break;
49854 case 5: var.destroy<CompleteFailureCauseInformation_List>(); break;
49856 type = 0; ref_nested().clear();
49858 template<typename V> static inline void enumerate(V& v)
49860 v.template operator()<Measurement_ID>(1);
49861 v.template operator()<Measurement_ID>(2);
49862 v.template operator()<Cause>(3);
49863 v.template operator()<CriticalityDiagnostics>(4);
49864 v.template operator()<CompleteFailureCauseInformation_List>(5);
49868 template<typename V> bool decode(size_t index, V& v)
49873 case 1: v(select_id_ENB1_Measurement_ID()); return true;
49874 case 2: v(select_id_ENB2_Measurement_ID()); return true;
49875 case 3: v(select_id_Cause()); return true;
49876 case 4: v(select_id_CriticalityDiagnostics()); return true;
49877 case 5: v(select_id_CompleteFailureCauseInformation_List()); return true;
49878 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
49883 template<typename V> bool encode(size_t index, V& v) const
49885 if(index != type) return false;
49888 case 1: v(var.as<Measurement_ID>()); return true;
49889 case 2: v(var.as<Measurement_ID>()); return true;
49890 case 3: v(var.as<Cause>()); return true;
49891 case 4: v(var.as<CriticalityDiagnostics>()); return true;
49892 case 5: v(var.as<CompleteFailureCauseInformation_List>()); return true;
49898 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49899 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49902 char dummy1[sizeof(Cause)];
49903 char dummy2[sizeof(CompleteFailureCauseInformation_List)];
49904 char dummy3[sizeof(CriticalityDiagnostics)];
49905 char dummy4[sizeof(Measurement_ID)];
49908 asn::variant<sizeof(union_type)> var;
49912 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49914 size_t get_index() const {return type;}
49915 bool is_unknown() const { return type == 6; }
49916 void clear() {type = 0;}
49917 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
49918 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
49919 void select_id_Cause() { set(mandatory); type=3;}
49920 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
49921 void select_id_CompleteFailureCauseInformation_List() { set(optional); type=5;}
49922 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49923 template<typename V> bool decode(V& v)
49926 if(!v(ref_nested())) return false;
49927 if(equal(mandatory)) { type = 1; return true; }
49928 else if(equal(mandatory)) { type = 2; return true; }
49929 else if(equal(mandatory)) { type = 3; return true; }
49930 else if(equal(optional)) { type = 4; return true; }
49931 else if(equal(optional)) { type = 5; return true; }
49932 else { type = 6; return true;}
49936 template<typename V> bool encode(V& v) const
49938 return v(ref_nested());
49942 template<typename V> bool decode(size_t index, V& v)
49947 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49948 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
49949 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
49950 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
49951 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
49952 case 6: type = 6; return v(ref_nested());
49953 ref_nested().clear();
49958 template<typename V> bool encode(size_t index, V& v) const
49960 if(index != type) {return false;} return v(ref_nested());
49970 ResourceStatusFailure ::= SEQUENCE {
49971 protocolIEs ProtocolIE-Container {{ResourceStatusFailure-IEs}},
49976 struct ResourceStatusFailure : asn::sequence<1, 0, true, 0>
49978 static constexpr const char* name() {return "ResourceStatusFailure";}
49979 using parent_t = asn::sequence<1, 0, true, 0>;
49980 struct protocolIEs_t : ProtocolIE_Container<ResourceStatusFailure_IEs>
49982 static constexpr const char* name() {return "protocolIEs_t";}
49983 using parent_t = ProtocolIE_Container<ResourceStatusFailure_IEs>;
49986 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49987 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49988 template<typename V> void decode(V& v)
49993 template<typename V> void encode(V& v) const
50000 protocolIEs.clear();
50004 protocolIEs_t protocolIEs;
50008 ResourceStatusRequest-IEs X2AP-PROTOCOL-IES ::= {
50009 { ID id-ENB1-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
50010 { ID id-ENB2-Measurement-ID CRITICALITY ignore TYPE Measurement-ID PRESENCE conditional}|-- The IE shall be present if the Registration Request IE is set to “Stop”, “Partial stop” or to “Add”--
50011 { ID id-Registration-Request CRITICALITY reject TYPE Registration-Request PRESENCE mandatory}|
50012 { ID id-ReportCharacteristics CRITICALITY reject TYPE ReportCharacteristics PRESENCE optional}|
50013 { ID id-CellToReport CRITICALITY ignore TYPE CellToReport-List PRESENCE mandatory}|
50014 { ID id-ReportingPeriodicity CRITICALITY ignore TYPE ReportingPeriodicity PRESENCE optional}|
50015 { ID id-PartialSuccessIndicator CRITICALITY ignore TYPE PartialSuccessIndicator PRESENCE optional}|
50016 { ID id-ReportingPeriodicityRSRPMR CRITICALITY ignore TYPE ReportingPeriodicityRSRPMR PRESENCE optional}|
50017 { ID id-ReportingPeriodicityCSIR CRITICALITY ignore TYPE ReportingPeriodicityCSIR PRESENCE optional},
50022 struct ResourceStatusRequest_IEs
50024 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50026 size_t get_index() const {return type;}
50027 bool is_unknown() const { return type == 10; }
50028 void clear() {type = 0;}
50029 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50030 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50031 void select_id_Registration_Request() { set(id_Registration_Request); type=3;}
50032 void select_id_ReportCharacteristics() { set(id_ReportCharacteristics); type=4;}
50033 void select_id_CellToReport() { set(id_CellToReport); type=5;}
50034 void select_id_ReportingPeriodicity() { set(id_ReportingPeriodicity); type=6;}
50035 void select_id_PartialSuccessIndicator() { set(id_PartialSuccessIndicator); type=7;}
50036 void select_id_ReportingPeriodicityRSRPMR() { set(id_ReportingPeriodicityRSRPMR); type=8;}
50037 void select_id_ReportingPeriodicityCSIR() { set(id_ReportingPeriodicityCSIR); type=9;}
50038 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50039 template<typename V> bool decode(V& v)
50042 if(!v(ref_nested())) return false;
50043 if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50044 else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50045 else if(equal(id_Registration_Request)) { type = 3; return true; }
50046 else if(equal(id_ReportCharacteristics)) { type = 4; return true; }
50047 else if(equal(id_CellToReport)) { type = 5; return true; }
50048 else if(equal(id_ReportingPeriodicity)) { type = 6; return true; }
50049 else if(equal(id_PartialSuccessIndicator)) { type = 7; return true; }
50050 else if(equal(id_ReportingPeriodicityRSRPMR)) { type = 8; return true; }
50051 else if(equal(id_ReportingPeriodicityCSIR)) { type = 9; return true; }
50052 else { type = 10; return true;}
50056 template<typename V> bool encode(V& v) const
50058 return v(ref_nested());
50062 template<typename V> bool decode(size_t index, V& v)
50067 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50068 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50069 case 3: type = 3; if(v(ref_nested())) { return equal(id_Registration_Request);} return false;
50070 case 4: type = 4; if(v(ref_nested())) { return equal(id_ReportCharacteristics);} return false;
50071 case 5: type = 5; if(v(ref_nested())) { return equal(id_CellToReport);} return false;
50072 case 6: type = 6; if(v(ref_nested())) { return equal(id_ReportingPeriodicity);} return false;
50073 case 7: type = 7; if(v(ref_nested())) { return equal(id_PartialSuccessIndicator);} return false;
50074 case 8: type = 8; if(v(ref_nested())) { return equal(id_ReportingPeriodicityRSRPMR);} return false;
50075 case 9: type = 9; if(v(ref_nested())) { return equal(id_ReportingPeriodicityCSIR);} return false;
50076 case 10: type = 10; return v(ref_nested());
50077 ref_nested().clear();
50082 template<typename V> bool encode(size_t index, V& v) const
50084 if(index != type) {return false;} return v(ref_nested());
50091 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50093 size_t get_index() const {return type;}
50094 bool is_unknown() const { return type == 10; }
50095 void clear() {type = 0;}
50096 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50097 void select_id_ENB2_Measurement_ID() { set(ignore); type=2;}
50098 void select_id_Registration_Request() { set(reject); type=3;}
50099 void select_id_ReportCharacteristics() { set(reject); type=4;}
50100 void select_id_CellToReport() { set(ignore); type=5;}
50101 void select_id_ReportingPeriodicity() { set(ignore); type=6;}
50102 void select_id_PartialSuccessIndicator() { set(ignore); type=7;}
50103 void select_id_ReportingPeriodicityRSRPMR() { set(ignore); type=8;}
50104 void select_id_ReportingPeriodicityCSIR() { set(ignore); type=9;}
50105 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50106 template<typename V> bool decode(V& v)
50109 if(!v(ref_nested())) return false;
50110 if(equal(reject)) { type = 1; return true; }
50111 else if(equal(ignore)) { type = 2; return true; }
50112 else if(equal(reject)) { type = 3; return true; }
50113 else if(equal(reject)) { type = 4; return true; }
50114 else if(equal(ignore)) { type = 5; return true; }
50115 else if(equal(ignore)) { type = 6; return true; }
50116 else if(equal(ignore)) { type = 7; return true; }
50117 else if(equal(ignore)) { type = 8; return true; }
50118 else if(equal(ignore)) { type = 9; return true; }
50119 else { type = 10; return true;}
50123 template<typename V> bool encode(V& v) const
50125 return v(ref_nested());
50129 template<typename V> bool decode(size_t index, V& v)
50134 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50135 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
50136 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
50137 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
50138 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
50139 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
50140 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
50141 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
50142 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
50143 case 10: type = 10; return v(ref_nested());
50144 ref_nested().clear();
50149 template<typename V> bool encode(size_t index, V& v) const
50151 if(index != type) {return false;} return v(ref_nested());
50158 struct Value_t : asn::typefield<true>
50160 ~Value_t() {clear();}
50161 size_t get_index() const {return type;}
50162 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50163 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50164 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50165 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50166 Registration_Request& select_id_Registration_Request() { return set<Registration_Request>(3); }
50167 Registration_Request const* get_id_Registration_Request() const { return get<Registration_Request>(3); }
50168 ReportCharacteristics& select_id_ReportCharacteristics() { return set<ReportCharacteristics>(4); }
50169 ReportCharacteristics const* get_id_ReportCharacteristics() const { return get<ReportCharacteristics>(4); }
50170 CellToReport_List& select_id_CellToReport() { return set<CellToReport_List>(5); }
50171 CellToReport_List const* get_id_CellToReport() const { return get<CellToReport_List>(5); }
50172 ReportingPeriodicity& select_id_ReportingPeriodicity() { return set<ReportingPeriodicity>(6); }
50173 ReportingPeriodicity const* get_id_ReportingPeriodicity() const { return get<ReportingPeriodicity>(6); }
50174 PartialSuccessIndicator& select_id_PartialSuccessIndicator() { return set<PartialSuccessIndicator>(7); }
50175 PartialSuccessIndicator const* get_id_PartialSuccessIndicator() const { return get<PartialSuccessIndicator>(7); }
50176 ReportingPeriodicityRSRPMR& select_id_ReportingPeriodicityRSRPMR() { return set<ReportingPeriodicityRSRPMR>(8); }
50177 ReportingPeriodicityRSRPMR const* get_id_ReportingPeriodicityRSRPMR() const { return get<ReportingPeriodicityRSRPMR>(8); }
50178 ReportingPeriodicityCSIR& select_id_ReportingPeriodicityCSIR() { return set<ReportingPeriodicityCSIR>(9); }
50179 ReportingPeriodicityCSIR const* get_id_ReportingPeriodicityCSIR() const { return get<ReportingPeriodicityCSIR>(9); }
50180 bool is_unknown() const { return type == 10; }
50185 case 1: var.destroy<Measurement_ID>(); break;
50186 case 2: var.destroy<Measurement_ID>(); break;
50187 case 3: var.destroy<Registration_Request>(); break;
50188 case 4: var.destroy<ReportCharacteristics>(); break;
50189 case 5: var.destroy<CellToReport_List>(); break;
50190 case 6: var.destroy<ReportingPeriodicity>(); break;
50191 case 7: var.destroy<PartialSuccessIndicator>(); break;
50192 case 8: var.destroy<ReportingPeriodicityRSRPMR>(); break;
50193 case 9: var.destroy<ReportingPeriodicityCSIR>(); break;
50195 type = 0; ref_nested().clear();
50197 template<typename V> static inline void enumerate(V& v)
50199 v.template operator()<Measurement_ID>(1);
50200 v.template operator()<Measurement_ID>(2);
50201 v.template operator()<Registration_Request>(3);
50202 v.template operator()<ReportCharacteristics>(4);
50203 v.template operator()<CellToReport_List>(5);
50204 v.template operator()<ReportingPeriodicity>(6);
50205 v.template operator()<PartialSuccessIndicator>(7);
50206 v.template operator()<ReportingPeriodicityRSRPMR>(8);
50207 v.template operator()<ReportingPeriodicityCSIR>(9);
50211 template<typename V> bool decode(size_t index, V& v)
50216 case 1: v(select_id_ENB1_Measurement_ID()); return true;
50217 case 2: v(select_id_ENB2_Measurement_ID()); return true;
50218 case 3: v(select_id_Registration_Request()); return true;
50219 case 4: v(select_id_ReportCharacteristics()); return true;
50220 case 5: v(select_id_CellToReport()); return true;
50221 case 6: v(select_id_ReportingPeriodicity()); return true;
50222 case 7: v(select_id_PartialSuccessIndicator()); return true;
50223 case 8: v(select_id_ReportingPeriodicityRSRPMR()); return true;
50224 case 9: v(select_id_ReportingPeriodicityCSIR()); return true;
50225 case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
50230 template<typename V> bool encode(size_t index, V& v) const
50232 if(index != type) return false;
50235 case 1: v(var.as<Measurement_ID>()); return true;
50236 case 2: v(var.as<Measurement_ID>()); return true;
50237 case 3: v(var.as<Registration_Request>()); return true;
50238 case 4: v(var.as<ReportCharacteristics>()); return true;
50239 case 5: v(var.as<CellToReport_List>()); return true;
50240 case 6: v(var.as<ReportingPeriodicity>()); return true;
50241 case 7: v(var.as<PartialSuccessIndicator>()); return true;
50242 case 8: v(var.as<ReportingPeriodicityRSRPMR>()); return true;
50243 case 9: v(var.as<ReportingPeriodicityCSIR>()); return true;
50249 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50250 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50253 char dummy1[sizeof(CellToReport_List)];
50254 char dummy2[sizeof(Measurement_ID)];
50255 char dummy3[sizeof(PartialSuccessIndicator)];
50256 char dummy4[sizeof(Registration_Request)];
50257 char dummy5[sizeof(ReportCharacteristics)];
50258 char dummy6[sizeof(ReportingPeriodicity)];
50259 char dummy7[sizeof(ReportingPeriodicityCSIR)];
50260 char dummy8[sizeof(ReportingPeriodicityRSRPMR)];
50263 asn::variant<sizeof(union_type)> var;
50267 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50269 size_t get_index() const {return type;}
50270 bool is_unknown() const { return type == 10; }
50271 void clear() {type = 0;}
50272 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50273 void select_id_ENB2_Measurement_ID() { set(conditional); type=2;}
50274 void select_id_Registration_Request() { set(mandatory); type=3;}
50275 void select_id_ReportCharacteristics() { set(optional); type=4;}
50276 void select_id_CellToReport() { set(mandatory); type=5;}
50277 void select_id_ReportingPeriodicity() { set(optional); type=6;}
50278 void select_id_PartialSuccessIndicator() { set(optional); type=7;}
50279 void select_id_ReportingPeriodicityRSRPMR() { set(optional); type=8;}
50280 void select_id_ReportingPeriodicityCSIR() { set(optional); type=9;}
50281 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50282 template<typename V> bool decode(V& v)
50285 if(!v(ref_nested())) return false;
50286 if(equal(mandatory)) { type = 1; return true; }
50287 else if(equal(conditional)) { type = 2; return true; }
50288 else if(equal(mandatory)) { type = 3; return true; }
50289 else if(equal(optional)) { type = 4; return true; }
50290 else if(equal(mandatory)) { type = 5; return true; }
50291 else if(equal(optional)) { type = 6; return true; }
50292 else if(equal(optional)) { type = 7; return true; }
50293 else if(equal(optional)) { type = 8; return true; }
50294 else if(equal(optional)) { type = 9; return true; }
50295 else { type = 10; return true;}
50299 template<typename V> bool encode(V& v) const
50301 return v(ref_nested());
50305 template<typename V> bool decode(size_t index, V& v)
50310 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50311 case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
50312 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
50313 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
50314 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
50315 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
50316 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
50317 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
50318 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
50319 case 10: type = 10; return v(ref_nested());
50320 ref_nested().clear();
50325 template<typename V> bool encode(size_t index, V& v) const
50327 if(index != type) {return false;} return v(ref_nested());
50337 ResourceStatusRequest ::= SEQUENCE {
50338 protocolIEs ProtocolIE-Container {{ResourceStatusRequest-IEs}},
50343 struct ResourceStatusRequest : asn::sequence<1, 0, true, 0>
50345 static constexpr const char* name() {return "ResourceStatusRequest";}
50346 using parent_t = asn::sequence<1, 0, true, 0>;
50347 struct protocolIEs_t : ProtocolIE_Container<ResourceStatusRequest_IEs>
50349 static constexpr const char* name() {return "protocolIEs_t";}
50350 using parent_t = ProtocolIE_Container<ResourceStatusRequest_IEs>;
50353 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50354 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50355 template<typename V> void decode(V& v)
50360 template<typename V> void encode(V& v) const
50367 protocolIEs.clear();
50371 protocolIEs_t protocolIEs;
50375 ResourceStatusResponse-IEs X2AP-PROTOCOL-IES ::= {
50376 { ID id-ENB1-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
50377 { ID id-ENB2-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
50378 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
50379 { ID id-MeasurementInitiationResult-List CRITICALITY ignore TYPE MeasurementInitiationResult-List PRESENCE optional},
50384 struct ResourceStatusResponse_IEs
50386 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50388 size_t get_index() const {return type;}
50389 bool is_unknown() const { return type == 5; }
50390 void clear() {type = 0;}
50391 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50392 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50393 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
50394 void select_id_MeasurementInitiationResult_List() { set(id_MeasurementInitiationResult_List); type=4;}
50395 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50396 template<typename V> bool decode(V& v)
50399 if(!v(ref_nested())) return false;
50400 if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50401 else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50402 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
50403 else if(equal(id_MeasurementInitiationResult_List)) { type = 4; return true; }
50404 else { type = 5; return true;}
50408 template<typename V> bool encode(V& v) const
50410 return v(ref_nested());
50414 template<typename V> bool decode(size_t index, V& v)
50419 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50420 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50421 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
50422 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeasurementInitiationResult_List);} return false;
50423 case 5: type = 5; return v(ref_nested());
50424 ref_nested().clear();
50429 template<typename V> bool encode(size_t index, V& v) const
50431 if(index != type) {return false;} return v(ref_nested());
50438 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50440 size_t get_index() const {return type;}
50441 bool is_unknown() const { return type == 5; }
50442 void clear() {type = 0;}
50443 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50444 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
50445 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
50446 void select_id_MeasurementInitiationResult_List() { set(ignore); type=4;}
50447 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50448 template<typename V> bool decode(V& v)
50451 if(!v(ref_nested())) return false;
50452 if(equal(reject)) { type = 1; return true; }
50453 else if(equal(reject)) { type = 2; return true; }
50454 else if(equal(ignore)) { type = 3; return true; }
50455 else if(equal(ignore)) { type = 4; return true; }
50456 else { type = 5; return true;}
50460 template<typename V> bool encode(V& v) const
50462 return v(ref_nested());
50466 template<typename V> bool decode(size_t index, V& v)
50471 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50472 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
50473 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
50474 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
50475 case 5: type = 5; return v(ref_nested());
50476 ref_nested().clear();
50481 template<typename V> bool encode(size_t index, V& v) const
50483 if(index != type) {return false;} return v(ref_nested());
50490 struct Value_t : asn::typefield<true>
50492 ~Value_t() {clear();}
50493 size_t get_index() const {return type;}
50494 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50495 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50496 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50497 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50498 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
50499 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
50500 MeasurementInitiationResult_List& select_id_MeasurementInitiationResult_List() { return set<MeasurementInitiationResult_List>(4); }
50501 MeasurementInitiationResult_List const* get_id_MeasurementInitiationResult_List() const { return get<MeasurementInitiationResult_List>(4); }
50502 bool is_unknown() const { return type == 5; }
50507 case 1: var.destroy<Measurement_ID>(); break;
50508 case 2: var.destroy<Measurement_ID>(); break;
50509 case 3: var.destroy<CriticalityDiagnostics>(); break;
50510 case 4: var.destroy<MeasurementInitiationResult_List>(); break;
50512 type = 0; ref_nested().clear();
50514 template<typename V> static inline void enumerate(V& v)
50516 v.template operator()<Measurement_ID>(1);
50517 v.template operator()<Measurement_ID>(2);
50518 v.template operator()<CriticalityDiagnostics>(3);
50519 v.template operator()<MeasurementInitiationResult_List>(4);
50523 template<typename V> bool decode(size_t index, V& v)
50528 case 1: v(select_id_ENB1_Measurement_ID()); return true;
50529 case 2: v(select_id_ENB2_Measurement_ID()); return true;
50530 case 3: v(select_id_CriticalityDiagnostics()); return true;
50531 case 4: v(select_id_MeasurementInitiationResult_List()); return true;
50532 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
50537 template<typename V> bool encode(size_t index, V& v) const
50539 if(index != type) return false;
50542 case 1: v(var.as<Measurement_ID>()); return true;
50543 case 2: v(var.as<Measurement_ID>()); return true;
50544 case 3: v(var.as<CriticalityDiagnostics>()); return true;
50545 case 4: v(var.as<MeasurementInitiationResult_List>()); return true;
50551 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50552 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50555 char dummy1[sizeof(CriticalityDiagnostics)];
50556 char dummy2[sizeof(MeasurementInitiationResult_List)];
50557 char dummy3[sizeof(Measurement_ID)];
50560 asn::variant<sizeof(union_type)> var;
50564 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50566 size_t get_index() const {return type;}
50567 bool is_unknown() const { return type == 5; }
50568 void clear() {type = 0;}
50569 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50570 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
50571 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
50572 void select_id_MeasurementInitiationResult_List() { set(optional); type=4;}
50573 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50574 template<typename V> bool decode(V& v)
50577 if(!v(ref_nested())) return false;
50578 if(equal(mandatory)) { type = 1; return true; }
50579 else if(equal(mandatory)) { type = 2; return true; }
50580 else if(equal(optional)) { type = 3; return true; }
50581 else if(equal(optional)) { type = 4; return true; }
50582 else { type = 5; return true;}
50586 template<typename V> bool encode(V& v) const
50588 return v(ref_nested());
50592 template<typename V> bool decode(size_t index, V& v)
50597 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50598 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
50599 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
50600 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
50601 case 5: type = 5; return v(ref_nested());
50602 ref_nested().clear();
50607 template<typename V> bool encode(size_t index, V& v) const
50609 if(index != type) {return false;} return v(ref_nested());
50619 ResourceStatusResponse ::= SEQUENCE {
50620 protocolIEs ProtocolIE-Container {{ResourceStatusResponse-IEs}},
50625 struct ResourceStatusResponse : asn::sequence<1, 0, true, 0>
50627 static constexpr const char* name() {return "ResourceStatusResponse";}
50628 using parent_t = asn::sequence<1, 0, true, 0>;
50629 struct protocolIEs_t : ProtocolIE_Container<ResourceStatusResponse_IEs>
50631 static constexpr const char* name() {return "protocolIEs_t";}
50632 using parent_t = ProtocolIE_Container<ResourceStatusResponse_IEs>;
50635 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50636 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50637 template<typename V> void decode(V& v)
50642 template<typename V> void encode(V& v) const
50649 protocolIEs.clear();
50653 protocolIEs_t protocolIEs;
50657 ResourceStatusUpdate-IEs X2AP-PROTOCOL-IES ::= {
50658 { ID id-ENB1-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
50659 { ID id-ENB2-Measurement-ID CRITICALITY reject TYPE Measurement-ID PRESENCE mandatory}|
50660 { ID id-CellMeasurementResult CRITICALITY ignore TYPE CellMeasurementResult-List PRESENCE mandatory},
50665 struct ResourceStatusUpdate_IEs
50667 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50669 size_t get_index() const {return type;}
50670 bool is_unknown() const { return type == 4; }
50671 void clear() {type = 0;}
50672 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50673 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50674 void select_id_CellMeasurementResult() { set(id_CellMeasurementResult); type=3;}
50675 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50676 template<typename V> bool decode(V& v)
50679 if(!v(ref_nested())) return false;
50680 if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50681 else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50682 else if(equal(id_CellMeasurementResult)) { type = 3; return true; }
50683 else { type = 4; return true;}
50687 template<typename V> bool encode(V& v) const
50689 return v(ref_nested());
50693 template<typename V> bool decode(size_t index, V& v)
50698 case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50699 case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50700 case 3: type = 3; if(v(ref_nested())) { return equal(id_CellMeasurementResult);} return false;
50701 case 4: type = 4; return v(ref_nested());
50702 ref_nested().clear();
50707 template<typename V> bool encode(size_t index, V& v) const
50709 if(index != type) {return false;} return v(ref_nested());
50716 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50718 size_t get_index() const {return type;}
50719 bool is_unknown() const { return type == 4; }
50720 void clear() {type = 0;}
50721 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50722 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
50723 void select_id_CellMeasurementResult() { set(ignore); type=3;}
50724 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50725 template<typename V> bool decode(V& v)
50728 if(!v(ref_nested())) return false;
50729 if(equal(reject)) { type = 1; return true; }
50730 else if(equal(reject)) { type = 2; return true; }
50731 else if(equal(ignore)) { type = 3; return true; }
50732 else { type = 4; return true;}
50736 template<typename V> bool encode(V& v) const
50738 return v(ref_nested());
50742 template<typename V> bool decode(size_t index, V& v)
50747 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50748 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
50749 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
50750 case 4: type = 4; return v(ref_nested());
50751 ref_nested().clear();
50756 template<typename V> bool encode(size_t index, V& v) const
50758 if(index != type) {return false;} return v(ref_nested());
50765 struct Value_t : asn::typefield<true>
50767 ~Value_t() {clear();}
50768 size_t get_index() const {return type;}
50769 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50770 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50771 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50772 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50773 CellMeasurementResult_List& select_id_CellMeasurementResult() { return set<CellMeasurementResult_List>(3); }
50774 CellMeasurementResult_List const* get_id_CellMeasurementResult() const { return get<CellMeasurementResult_List>(3); }
50775 bool is_unknown() const { return type == 4; }
50780 case 1: var.destroy<Measurement_ID>(); break;
50781 case 2: var.destroy<Measurement_ID>(); break;
50782 case 3: var.destroy<CellMeasurementResult_List>(); break;
50784 type = 0; ref_nested().clear();
50786 template<typename V> static inline void enumerate(V& v)
50788 v.template operator()<Measurement_ID>(1);
50789 v.template operator()<Measurement_ID>(2);
50790 v.template operator()<CellMeasurementResult_List>(3);
50794 template<typename V> bool decode(size_t index, V& v)
50799 case 1: v(select_id_ENB1_Measurement_ID()); return true;
50800 case 2: v(select_id_ENB2_Measurement_ID()); return true;
50801 case 3: v(select_id_CellMeasurementResult()); return true;
50802 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
50807 template<typename V> bool encode(size_t index, V& v) const
50809 if(index != type) return false;
50812 case 1: v(var.as<Measurement_ID>()); return true;
50813 case 2: v(var.as<Measurement_ID>()); return true;
50814 case 3: v(var.as<CellMeasurementResult_List>()); return true;
50820 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50821 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50824 char dummy1[sizeof(CellMeasurementResult_List)];
50825 char dummy2[sizeof(Measurement_ID)];
50828 asn::variant<sizeof(union_type)> var;
50832 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50834 size_t get_index() const {return type;}
50835 bool is_unknown() const { return type == 4; }
50836 void clear() {type = 0;}
50837 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50838 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
50839 void select_id_CellMeasurementResult() { set(mandatory); type=3;}
50840 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50841 template<typename V> bool decode(V& v)
50844 if(!v(ref_nested())) return false;
50845 if(equal(mandatory)) { type = 1; return true; }
50846 else if(equal(mandatory)) { type = 2; return true; }
50847 else if(equal(mandatory)) { type = 3; return true; }
50848 else { type = 4; return true;}
50852 template<typename V> bool encode(V& v) const
50854 return v(ref_nested());
50858 template<typename V> bool decode(size_t index, V& v)
50863 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50864 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
50865 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
50866 case 4: type = 4; return v(ref_nested());
50867 ref_nested().clear();
50872 template<typename V> bool encode(size_t index, V& v) const
50874 if(index != type) {return false;} return v(ref_nested());
50884 ResourceStatusUpdate ::= SEQUENCE {
50885 protocolIEs ProtocolIE-Container {{ResourceStatusUpdate-IEs}},
50890 struct ResourceStatusUpdate : asn::sequence<1, 0, true, 0>
50892 static constexpr const char* name() {return "ResourceStatusUpdate";}
50893 using parent_t = asn::sequence<1, 0, true, 0>;
50894 struct protocolIEs_t : ProtocolIE_Container<ResourceStatusUpdate_IEs>
50896 static constexpr const char* name() {return "protocolIEs_t";}
50897 using parent_t = ProtocolIE_Container<ResourceStatusUpdate_IEs>;
50900 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50901 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50902 template<typename V> void decode(V& v)
50907 template<typename V> void encode(V& v) const
50914 protocolIEs.clear();
50918 protocolIEs_t protocolIEs;
50922 ResponseInformationSeNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
50927 struct ResponseInformationSeNBReconfComp_SuccessItemExtIEs
50929 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
50931 size_t get_index() const {return type;}
50932 bool is_unknown() const { return type == 1; }
50933 void clear() {type = 0;}
50934 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
50935 template<typename V> bool decode(V& v)
50938 if(!v(ref_nested())) return false;
50939 { type = 1; return true;}
50943 template<typename V> bool encode(V& v) const
50945 return v(ref_nested());
50949 template<typename V> bool decode(size_t index, V& v)
50954 case 1: type = 1; return v(ref_nested());
50955 ref_nested().clear();
50960 template<typename V> bool encode(size_t index, V& v) const
50962 if(index != type) {return false;} return v(ref_nested());
50969 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
50971 size_t get_index() const {return type;}
50972 bool is_unknown() const { return type == 1; }
50973 void clear() {type = 0;}
50974 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
50975 template<typename V> bool decode(V& v)
50978 if(!v(ref_nested())) return false;
50979 { type = 1; return true;}
50983 template<typename V> bool encode(V& v) const
50985 return v(ref_nested());
50989 template<typename V> bool decode(size_t index, V& v)
50994 case 1: type = 1; return v(ref_nested());
50995 ref_nested().clear();
51000 template<typename V> bool encode(size_t index, V& v) const
51002 if(index != type) {return false;} return v(ref_nested());
51009 struct Extension_t : asn::typefield<true>
51011 ~Extension_t() {clear();}
51012 size_t get_index() const {return type;}
51013 bool is_unknown() const { return type == 1; }
51016 type = 0; ref_nested().clear();
51018 template<typename V> static inline void enumerate(V& v)
51023 template<typename V> bool decode(size_t index, V& v)
51028 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51033 template<typename V> bool encode(size_t index, V& v) const
51035 if(index != type) return false;
51043 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51045 size_t get_index() const {return type;}
51046 bool is_unknown() const { return type == 1; }
51047 void clear() {type = 0;}
51048 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51049 template<typename V> bool decode(V& v)
51052 if(!v(ref_nested())) return false;
51053 { type = 1; return true;}
51057 template<typename V> bool encode(V& v) const
51059 return v(ref_nested());
51063 template<typename V> bool decode(size_t index, V& v)
51068 case 1: type = 1; return v(ref_nested());
51069 ref_nested().clear();
51074 template<typename V> bool encode(size_t index, V& v) const
51076 if(index != type) {return false;} return v(ref_nested());
51086 ResponseInformationSeNBReconfComp-SuccessItem ::= SEQUENCE {
51087 meNBtoSeNBContainer MeNBtoSeNBContainer OPTIONAL,
51088 iE-Extensions ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-SuccessItemExtIEs} } OPTIONAL,
51093 struct ResponseInformationSeNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
51095 static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-SuccessItem";}
51096 using parent_t = asn::sequence<2, 0, true, 2>;
51097 struct meNBtoSeNBContainer_t : MeNBtoSeNBContainer
51099 static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
51100 using parent_t = MeNBtoSeNBContainer;
51101 static constexpr bool optional = true;
51104 meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
51105 meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
51106 struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>
51108 static constexpr const char* name() {return "iE_Extensions_t";}
51109 using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>;
51110 static constexpr bool optional = true;
51113 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51114 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51115 template<typename V> void decode(V& v)
51117 v(meNBtoSeNBContainer);
51121 template<typename V> void encode(V& v) const
51123 v(meNBtoSeNBContainer);
51129 meNBtoSeNBContainer.clear();
51130 iE_Extensions.clear();
51134 meNBtoSeNBContainer_t meNBtoSeNBContainer;
51135 iE_Extensions_t iE_Extensions;
51139 ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51144 struct ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs
51146 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51148 size_t get_index() const {return type;}
51149 bool is_unknown() const { return type == 1; }
51150 void clear() {type = 0;}
51151 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51152 template<typename V> bool decode(V& v)
51155 if(!v(ref_nested())) return false;
51156 { type = 1; return true;}
51160 template<typename V> bool encode(V& v) const
51162 return v(ref_nested());
51166 template<typename V> bool decode(size_t index, V& v)
51171 case 1: type = 1; return v(ref_nested());
51172 ref_nested().clear();
51177 template<typename V> bool encode(size_t index, V& v) const
51179 if(index != type) {return false;} return v(ref_nested());
51186 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51188 size_t get_index() const {return type;}
51189 bool is_unknown() const { return type == 1; }
51190 void clear() {type = 0;}
51191 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51192 template<typename V> bool decode(V& v)
51195 if(!v(ref_nested())) return false;
51196 { type = 1; return true;}
51200 template<typename V> bool encode(V& v) const
51202 return v(ref_nested());
51206 template<typename V> bool decode(size_t index, V& v)
51211 case 1: type = 1; return v(ref_nested());
51212 ref_nested().clear();
51217 template<typename V> bool encode(size_t index, V& v) const
51219 if(index != type) {return false;} return v(ref_nested());
51226 struct Extension_t : asn::typefield<true>
51228 ~Extension_t() {clear();}
51229 size_t get_index() const {return type;}
51230 bool is_unknown() const { return type == 1; }
51233 type = 0; ref_nested().clear();
51235 template<typename V> static inline void enumerate(V& v)
51240 template<typename V> bool decode(size_t index, V& v)
51245 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51250 template<typename V> bool encode(size_t index, V& v) const
51252 if(index != type) return false;
51260 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51262 size_t get_index() const {return type;}
51263 bool is_unknown() const { return type == 1; }
51264 void clear() {type = 0;}
51265 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51266 template<typename V> bool decode(V& v)
51269 if(!v(ref_nested())) return false;
51270 { type = 1; return true;}
51274 template<typename V> bool encode(V& v) const
51276 return v(ref_nested());
51280 template<typename V> bool decode(size_t index, V& v)
51285 case 1: type = 1; return v(ref_nested());
51286 ref_nested().clear();
51291 template<typename V> bool encode(size_t index, V& v) const
51293 if(index != type) {return false;} return v(ref_nested());
51303 ResponseInformationSeNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
51305 meNBtoSeNBContainer MeNBtoSeNBContainer OPTIONAL,
51306 iE-Extensions ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs} } OPTIONAL,
51311 struct ResponseInformationSeNBReconfComp_RejectByMeNBItem : asn::sequence<3, 0, true, 2>
51313 static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-RejectByMeNBItem";}
51314 using parent_t = asn::sequence<3, 0, true, 2>;
51315 struct cause_t : Cause
51317 static constexpr const char* name() {return "cause_t";}
51318 using parent_t = Cause;
51321 cause_t& ref_cause() {return cause;}
51322 cause_t const& ref_cause() const {return cause;}
51323 struct meNBtoSeNBContainer_t : MeNBtoSeNBContainer
51325 static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
51326 using parent_t = MeNBtoSeNBContainer;
51327 static constexpr bool optional = true;
51330 meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
51331 meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
51332 struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>
51334 static constexpr const char* name() {return "iE_Extensions_t";}
51335 using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>;
51336 static constexpr bool optional = true;
51339 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51340 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51341 template<typename V> void decode(V& v)
51344 v(meNBtoSeNBContainer);
51348 template<typename V> void encode(V& v) const
51351 v(meNBtoSeNBContainer);
51358 meNBtoSeNBContainer.clear();
51359 iE_Extensions.clear();
51364 meNBtoSeNBContainer_t meNBtoSeNBContainer;
51365 iE_Extensions_t iE_Extensions;
51369 ResponseInformationSeNBReconfComp ::= CHOICE {
51370 success ResponseInformationSeNBReconfComp-SuccessItem,
51371 reject-by-MeNB ResponseInformationSeNBReconfComp-RejectByMeNBItem,
51376 struct ResponseInformationSeNBReconfComp : asn::choice<2, 0, true>
51378 static constexpr const char* name() {return "ResponseInformationSeNBReconfComp";}
51379 using parent_t = asn::choice<2, 0, true>;
51380 index_type get_index() const {return index;}
51381 bool is_unknown() const {return index == 3;}
51382 void set_unknown() { set_index(3); }
51383 ~ResponseInformationSeNBReconfComp() {clear();}
51384 struct success_t : ResponseInformationSeNBReconfComp_SuccessItem
51386 static constexpr const char* name() {return "success_t";}
51387 using parent_t = ResponseInformationSeNBReconfComp_SuccessItem;
51390 struct reject_by_MeNB_t : ResponseInformationSeNBReconfComp_RejectByMeNBItem
51392 static constexpr const char* name() {return "reject_by_MeNB_t";}
51393 using parent_t = ResponseInformationSeNBReconfComp_RejectByMeNBItem;
51398 switch(get_index())
51400 case 1: var.destroy<success_t>(); break;
51401 case 2: var.destroy<reject_by_MeNB_t>(); break;
51406 template<typename V> bool decode(size_t idx, V& v)
51411 case 1: set_index(1); return v(var.build<success_t>());
51412 case 2: set_index(2); return v(var.build<reject_by_MeNB_t>());
51417 template<typename V> bool encode(V& v) const
51419 switch(get_index())
51421 case 1: return v(var.as<success_t>());
51422 case 2: return v(var.as<reject_by_MeNB_t>());
51426 template<typename V> static inline void enumerate(V& v)
51428 v.template operator()<success_t>(1);
51429 v.template operator()<reject_by_MeNB_t>(2);
51432 success_t& select_success() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_t>();} return var.as<success_t>();}
51433 success_t const* get_success() const { if(get_index() == 1) { return &var.as<success_t>();} return nullptr; }
51434 reject_by_MeNB_t& select_reject_by_MeNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_t>();} return var.as<reject_by_MeNB_t>();}
51435 reject_by_MeNB_t const* get_reject_by_MeNB() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_t>();} return nullptr; }
51437 void set_index(index_type i) {index = i; base::set();}
51440 char dummy1[sizeof(success_t)];
51441 char dummy2[sizeof(reject_by_MeNB_t)];
51444 asn::variant<sizeof(union_type)> var;
51445 index_type index {0};
51448 ResponseInformationSgNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51453 struct ResponseInformationSgNBReconfComp_SuccessItemExtIEs
51455 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51457 size_t get_index() const {return type;}
51458 bool is_unknown() const { return type == 1; }
51459 void clear() {type = 0;}
51460 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51461 template<typename V> bool decode(V& v)
51464 if(!v(ref_nested())) return false;
51465 { type = 1; return true;}
51469 template<typename V> bool encode(V& v) const
51471 return v(ref_nested());
51475 template<typename V> bool decode(size_t index, V& v)
51480 case 1: type = 1; return v(ref_nested());
51481 ref_nested().clear();
51486 template<typename V> bool encode(size_t index, V& v) const
51488 if(index != type) {return false;} return v(ref_nested());
51495 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51497 size_t get_index() const {return type;}
51498 bool is_unknown() const { return type == 1; }
51499 void clear() {type = 0;}
51500 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51501 template<typename V> bool decode(V& v)
51504 if(!v(ref_nested())) return false;
51505 { type = 1; return true;}
51509 template<typename V> bool encode(V& v) const
51511 return v(ref_nested());
51515 template<typename V> bool decode(size_t index, V& v)
51520 case 1: type = 1; return v(ref_nested());
51521 ref_nested().clear();
51526 template<typename V> bool encode(size_t index, V& v) const
51528 if(index != type) {return false;} return v(ref_nested());
51535 struct Extension_t : asn::typefield<true>
51537 ~Extension_t() {clear();}
51538 size_t get_index() const {return type;}
51539 bool is_unknown() const { return type == 1; }
51542 type = 0; ref_nested().clear();
51544 template<typename V> static inline void enumerate(V& v)
51549 template<typename V> bool decode(size_t index, V& v)
51554 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51559 template<typename V> bool encode(size_t index, V& v) const
51561 if(index != type) return false;
51569 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51571 size_t get_index() const {return type;}
51572 bool is_unknown() const { return type == 1; }
51573 void clear() {type = 0;}
51574 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51575 template<typename V> bool decode(V& v)
51578 if(!v(ref_nested())) return false;
51579 { type = 1; return true;}
51583 template<typename V> bool encode(V& v) const
51585 return v(ref_nested());
51589 template<typename V> bool decode(size_t index, V& v)
51594 case 1: type = 1; return v(ref_nested());
51595 ref_nested().clear();
51600 template<typename V> bool encode(size_t index, V& v) const
51602 if(index != type) {return false;} return v(ref_nested());
51612 ResponseInformationSgNBReconfComp-SuccessItem ::= SEQUENCE {
51613 meNBtoSgNBContainer MeNBtoSgNBContainer OPTIONAL,
51614 iE-Extensions ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-SuccessItemExtIEs} } OPTIONAL,
51619 struct ResponseInformationSgNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
51621 static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-SuccessItem";}
51622 using parent_t = asn::sequence<2, 0, true, 2>;
51623 struct meNBtoSgNBContainer_t : MeNBtoSgNBContainer
51625 static constexpr const char* name() {return "meNBtoSgNBContainer_t";}
51626 using parent_t = MeNBtoSgNBContainer;
51627 static constexpr bool optional = true;
51630 meNBtoSgNBContainer_t& set_meNBtoSgNBContainer() { meNBtoSgNBContainer.setpresent(true); return meNBtoSgNBContainer;}
51631 meNBtoSgNBContainer_t const* get_meNBtoSgNBContainer() const {return meNBtoSgNBContainer.is_valid() ? &meNBtoSgNBContainer : nullptr;}
51632 struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>
51634 static constexpr const char* name() {return "iE_Extensions_t";}
51635 using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>;
51636 static constexpr bool optional = true;
51639 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51640 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51641 template<typename V> void decode(V& v)
51643 v(meNBtoSgNBContainer);
51647 template<typename V> void encode(V& v) const
51649 v(meNBtoSgNBContainer);
51655 meNBtoSgNBContainer.clear();
51656 iE_Extensions.clear();
51660 meNBtoSgNBContainer_t meNBtoSgNBContainer;
51661 iE_Extensions_t iE_Extensions;
51665 ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51670 struct ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs
51672 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51674 size_t get_index() const {return type;}
51675 bool is_unknown() const { return type == 1; }
51676 void clear() {type = 0;}
51677 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51678 template<typename V> bool decode(V& v)
51681 if(!v(ref_nested())) return false;
51682 { type = 1; return true;}
51686 template<typename V> bool encode(V& v) const
51688 return v(ref_nested());
51692 template<typename V> bool decode(size_t index, V& v)
51697 case 1: type = 1; return v(ref_nested());
51698 ref_nested().clear();
51703 template<typename V> bool encode(size_t index, V& v) const
51705 if(index != type) {return false;} return v(ref_nested());
51712 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51714 size_t get_index() const {return type;}
51715 bool is_unknown() const { return type == 1; }
51716 void clear() {type = 0;}
51717 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51718 template<typename V> bool decode(V& v)
51721 if(!v(ref_nested())) return false;
51722 { type = 1; return true;}
51726 template<typename V> bool encode(V& v) const
51728 return v(ref_nested());
51732 template<typename V> bool decode(size_t index, V& v)
51737 case 1: type = 1; return v(ref_nested());
51738 ref_nested().clear();
51743 template<typename V> bool encode(size_t index, V& v) const
51745 if(index != type) {return false;} return v(ref_nested());
51752 struct Extension_t : asn::typefield<true>
51754 ~Extension_t() {clear();}
51755 size_t get_index() const {return type;}
51756 bool is_unknown() const { return type == 1; }
51759 type = 0; ref_nested().clear();
51761 template<typename V> static inline void enumerate(V& v)
51766 template<typename V> bool decode(size_t index, V& v)
51771 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51776 template<typename V> bool encode(size_t index, V& v) const
51778 if(index != type) return false;
51786 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51788 size_t get_index() const {return type;}
51789 bool is_unknown() const { return type == 1; }
51790 void clear() {type = 0;}
51791 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51792 template<typename V> bool decode(V& v)
51795 if(!v(ref_nested())) return false;
51796 { type = 1; return true;}
51800 template<typename V> bool encode(V& v) const
51802 return v(ref_nested());
51806 template<typename V> bool decode(size_t index, V& v)
51811 case 1: type = 1; return v(ref_nested());
51812 ref_nested().clear();
51817 template<typename V> bool encode(size_t index, V& v) const
51819 if(index != type) {return false;} return v(ref_nested());
51829 ResponseInformationSgNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
51831 iE-Extensions ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs} } OPTIONAL,
51836 struct ResponseInformationSgNBReconfComp_RejectByMeNBItem : asn::sequence<2, 0, true, 1>
51838 static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-RejectByMeNBItem";}
51839 using parent_t = asn::sequence<2, 0, true, 1>;
51840 struct cause_t : Cause
51842 static constexpr const char* name() {return "cause_t";}
51843 using parent_t = Cause;
51846 cause_t& ref_cause() {return cause;}
51847 cause_t const& ref_cause() const {return cause;}
51848 struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>
51850 static constexpr const char* name() {return "iE_Extensions_t";}
51851 using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>;
51852 static constexpr bool optional = true;
51855 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51856 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51857 template<typename V> void decode(V& v)
51863 template<typename V> void encode(V& v) const
51872 iE_Extensions.clear();
51877 iE_Extensions_t iE_Extensions;
51881 ResponseInformationSgNBReconfComp ::= CHOICE {
51882 success-SgNBReconfComp ResponseInformationSgNBReconfComp-SuccessItem,
51883 reject-by-MeNB-SgNBReconfComp ResponseInformationSgNBReconfComp-RejectByMeNBItem,
51888 struct ResponseInformationSgNBReconfComp : asn::choice<2, 0, true>
51890 static constexpr const char* name() {return "ResponseInformationSgNBReconfComp";}
51891 using parent_t = asn::choice<2, 0, true>;
51892 index_type get_index() const {return index;}
51893 bool is_unknown() const {return index == 3;}
51894 void set_unknown() { set_index(3); }
51895 ~ResponseInformationSgNBReconfComp() {clear();}
51896 struct success_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_SuccessItem
51898 static constexpr const char* name() {return "success_SgNBReconfComp_t";}
51899 using parent_t = ResponseInformationSgNBReconfComp_SuccessItem;
51902 struct reject_by_MeNB_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_RejectByMeNBItem
51904 static constexpr const char* name() {return "reject_by_MeNB_SgNBReconfComp_t";}
51905 using parent_t = ResponseInformationSgNBReconfComp_RejectByMeNBItem;
51910 switch(get_index())
51912 case 1: var.destroy<success_SgNBReconfComp_t>(); break;
51913 case 2: var.destroy<reject_by_MeNB_SgNBReconfComp_t>(); break;
51918 template<typename V> bool decode(size_t idx, V& v)
51923 case 1: set_index(1); return v(var.build<success_SgNBReconfComp_t>());
51924 case 2: set_index(2); return v(var.build<reject_by_MeNB_SgNBReconfComp_t>());
51929 template<typename V> bool encode(V& v) const
51931 switch(get_index())
51933 case 1: return v(var.as<success_SgNBReconfComp_t>());
51934 case 2: return v(var.as<reject_by_MeNB_SgNBReconfComp_t>());
51938 template<typename V> static inline void enumerate(V& v)
51940 v.template operator()<success_SgNBReconfComp_t>(1);
51941 v.template operator()<reject_by_MeNB_SgNBReconfComp_t>(2);
51944 success_SgNBReconfComp_t& select_success_SgNBReconfComp() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_SgNBReconfComp_t>();} return var.as<success_SgNBReconfComp_t>();}
51945 success_SgNBReconfComp_t const* get_success_SgNBReconfComp() const { if(get_index() == 1) { return &var.as<success_SgNBReconfComp_t>();} return nullptr; }
51946 reject_by_MeNB_SgNBReconfComp_t& select_reject_by_MeNB_SgNBReconfComp() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_SgNBReconfComp_t>();} return var.as<reject_by_MeNB_SgNBReconfComp_t>();}
51947 reject_by_MeNB_SgNBReconfComp_t const* get_reject_by_MeNB_SgNBReconfComp() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_SgNBReconfComp_t>();} return nullptr; }
51949 void set_index(index_type i) {index = i; base::set();}
51952 char dummy1[sizeof(success_SgNBReconfComp_t)];
51953 char dummy2[sizeof(reject_by_MeNB_SgNBReconfComp_t)];
51956 asn::variant<sizeof(union_type)> var;
51957 index_type index {0};
51960 RetrieveUEContextFailure-IEs X2AP-PROTOCOL-IES ::= {
51961 { ID id-New-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
51962 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
51963 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
51964 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
51969 struct RetrieveUEContextFailure_IEs
51971 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
51973 size_t get_index() const {return type;}
51974 bool is_unknown() const { return type == 5; }
51975 void clear() {type = 0;}
51976 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
51977 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
51978 void select_id_Cause() { set(id_Cause); type=3;}
51979 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
51980 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
51981 template<typename V> bool decode(V& v)
51984 if(!v(ref_nested())) return false;
51985 if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
51986 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
51987 else if(equal(id_Cause)) { type = 3; return true; }
51988 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
51989 else { type = 5; return true;}
51993 template<typename V> bool encode(V& v) const
51995 return v(ref_nested());
51999 template<typename V> bool decode(size_t index, V& v)
52004 case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
52005 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
52006 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
52007 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
52008 case 5: type = 5; return v(ref_nested());
52009 ref_nested().clear();
52014 template<typename V> bool encode(size_t index, V& v) const
52016 if(index != type) {return false;} return v(ref_nested());
52023 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
52025 size_t get_index() const {return type;}
52026 bool is_unknown() const { return type == 5; }
52027 void clear() {type = 0;}
52028 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
52029 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
52030 void select_id_Cause() { set(ignore); type=3;}
52031 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
52032 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
52033 template<typename V> bool decode(V& v)
52036 if(!v(ref_nested())) return false;
52037 if(equal(ignore)) { type = 1; return true; }
52038 else if(equal(ignore)) { type = 2; return true; }
52039 else if(equal(ignore)) { type = 3; return true; }
52040 else if(equal(ignore)) { type = 4; return true; }
52041 else { type = 5; return true;}
52045 template<typename V> bool encode(V& v) const
52047 return v(ref_nested());
52051 template<typename V> bool decode(size_t index, V& v)
52056 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
52057 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
52058 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
52059 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
52060 case 5: type = 5; return v(ref_nested());
52061 ref_nested().clear();
52066 template<typename V> bool encode(size_t index, V& v) const
52068 if(index != type) {return false;} return v(ref_nested());
52075 struct Value_t : asn::typefield<true>
52077 ~Value_t() {clear();}
52078 size_t get_index() const {return type;}
52079 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
52080 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
52081 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
52082 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
52083 Cause& select_id_Cause() { return set<Cause>(3); }
52084 Cause const* get_id_Cause() const { return get<Cause>(3); }
52085 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
52086 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
52087 bool is_unknown() const { return type == 5; }
52092 case 1: var.destroy<UE_X2AP_ID>(); break;
52093 case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
52094 case 3: var.destroy<Cause>(); break;
52095 case 4: var.destroy<CriticalityDiagnostics>(); break;
52097 type = 0; ref_nested().clear();
52099 template<typename V> static inline void enumerate(V& v)
52101 v.template operator()<UE_X2AP_ID>(1);
52102 v.template operator()<UE_X2AP_ID_Extension>(2);
52103 v.template operator()<Cause>(3);
52104 v.template operator()<CriticalityDiagnostics>(4);
52108 template<typename V> bool decode(size_t index, V& v)
52113 case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
52114 case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
52115 case 3: v(select_id_Cause()); return true;
52116 case 4: v(select_id_CriticalityDiagnostics()); return true;
52117 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
52122 template<typename V> bool encode(size_t index, V& v) const
52124 if(index != type) return false;
52127 case 1: v(var.as<UE_X2AP_ID>()); return true;
52128 case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
52129 case 3: v(var.as<Cause>()); return true;
52130 case 4: v(var.as<CriticalityDiagnostics>()); return true;
52136 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52137 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52140 char dummy1[sizeof(Cause)];
52141 char dummy2[sizeof(CriticalityDiagnostics)];
52142 char dummy3[sizeof(UE_X2AP_ID)];
52143 char dummy4[sizeof(UE_X2AP_ID_Extension)];
52146 asn::variant<sizeof(union_type)> var;
52150 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
52152 size_t get_index() const {return type;}
52153 bool is_unknown() const { return type == 5; }
52154 void clear() {type = 0;}
52155 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
52156 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
52157 void select_id_Cause() { set(mandatory); type=3;}
52158 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
52159 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
52160 template<typename V> bool decode(V& v)
52163 if(!v(ref_nested())) return false;
52164 if(equal(mandatory)) { type = 1; return true; }
52165 else if(equal(optional)) { type = 2; return true; }
52166 else if(equal(mandatory)) { type = 3; return true; }
52167 else if(equal(optional)) { type = 4; return true; }
52168 else { type = 5; return true;}
52172 template<typename V> bool encode(V& v) const
52174 return v(ref_nested());
52178 template<typename V> bool decode(size_t index, V& v)
52183 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
52184 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
52185 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
52186 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
52187 case 5: type = 5; return v(ref_nested());
52188 ref_nested().clear();
52193 template<typename V> bool encode(size_t index, V& v) const
52195 if(index != type) {return false;} return v(ref_nested());
52205 RetrieveUEContextFailure ::= SEQUENCE {
52206 protocolIEs ProtocolIE-Container {{ RetrieveUEContextFailure-IEs}},
52211 struct RetrieveUEContextFailure : asn::sequence<1, 0, true, 0>
52213 static constexpr const char* name() {return "RetrieveUEContextFailure";}
52214 using parent_t = asn::sequence<1, 0, true, 0>;
52215 struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextFailure_IEs>
52217 static constexpr const char* name() {return "protocolIEs_t";}
52218 using parent_t = ProtocolIE_Container<RetrieveUEContextFailure_IEs>;
52221 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
52222 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
52223 template<typename V> void decode(V& v)
52228 template<typename V> void encode(V& v) const
52235 protocolIEs.clear();
52239 protocolIEs_t protocolIEs;
52243 RetrieveUEContextRequest-IEs X2AP-PROTOCOL-IES ::= {
52244 { ID id-New-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
52245 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
52246 { ID id-resumeID CRITICALITY reject TYPE ResumeID PRESENCE mandatory}|
52247 { ID id-ShortMAC-I CRITICALITY reject TYPE ShortMAC-I PRESENCE mandatory}|
52248 { ID id-NewEUTRANCellIdentifier CRITICALITY reject TYPE EUTRANCellIdentifier PRESENCE mandatory}|
52249 {ID id-FailureCellCRNTI CRITICALITY reject TYPE CRNTI PRESENCE optional}|
52250 {ID id-FailureCellPCI CRITICALITY reject TYPE PCI PRESENCE optional},
52255 struct RetrieveUEContextRequest_IEs
52257 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
52259 size_t get_index() const {return type;}
52260 bool is_unknown() const { return type == 8; }
52261 void clear() {type = 0;}
52262 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
52263 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=2;}
52264 void select_id_resumeID() { set(id_resumeID); type=3;}
52265 void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
52266 void select_id_NewEUTRANCellIdentifier() { set(id_NewEUTRANCellIdentifier); type=5;}
52267 void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=6;}
52268 void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=7;}
52269 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
52270 template<typename V> bool decode(V& v)
52273 if(!v(ref_nested())) return false;
52274 if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
52275 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
52276 else if(equal(id_resumeID)) { type = 3; return true; }
52277 else if(equal(id_ShortMAC_I)) { type = 4; return true; }
52278 else if(equal(id_NewEUTRANCellIdentifier)) { type = 5; return true; }
52279 else if(equal(id_FailureCellCRNTI)) { type = 6; return true; }
52280 else if(equal(id_FailureCellPCI)) { type = 7; return true; }
52281 else { type = 8; return true;}
52285 template<typename V> bool encode(V& v) const
52287 return v(ref_nested());
52291 template<typename V> bool decode(size_t index, V& v)
52296 case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
52297 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
52298 case 3: type = 3; if(v(ref_nested())) { return equal(id_resumeID);} return false;
52299 case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
52300 case 5: type = 5; if(v(ref_nested())) { return equal(id_NewEUTRANCellIdentifier);} return false;
52301 case 6: type = 6; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
52302 case 7: type = 7; if(v(ref_nested())) { return equal(id_FailureCellPCI);} return false;
52303 case 8: type = 8; return v(ref_nested());
52304 ref_nested().clear();
52309 template<typename V> bool encode(size_t index, V& v) const
52311 if(index != type) {return false;} return v(ref_nested());
52318 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
52320 size_t get_index() const {return type;}
52321 bool is_unknown() const { return type == 8; }
52322 void clear() {type = 0;}
52323 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=1;}
52324 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=2;}
52325 void select_id_resumeID() { set(reject); type=3;}
52326 void select_id_ShortMAC_I() { set(reject); type=4;}
52327 void select_id_NewEUTRANCellIdentifier() { set(reject); type=5;}
52328 void select_id_FailureCellCRNTI() { set(reject); type=6;}
52329 void select_id_FailureCellPCI() { set(reject); type=7;}
52330 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
52331 template<typename V> bool decode(V& v)
52334 if(!v(ref_nested())) return false;
52335 if(equal(reject)) { type = 1; return true; }
52336 else if(equal(reject)) { type = 2; return true; }
52337 else if(equal(reject)) { type = 3; return true; }
52338 else if(equal(reject)) { type = 4; return true; }
52339 else if(equal(reject)) { type = 5; return true; }
52340 else if(equal(reject)) { type = 6; return true; }
52341 else if(equal(reject)) { type = 7; return true; }
52342 else { type = 8; return true;}
52346 template<typename V> bool encode(V& v) const
52348 return v(ref_nested());
52352 template<typename V> bool decode(size_t index, V& v)
52357 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
52358 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
52359 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
52360 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
52361 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
52362 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
52363 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
52364 case 8: type = 8; return v(ref_nested());
52365 ref_nested().clear();
52370 template<typename V> bool encode(size_t index, V& v) const
52372 if(index != type) {return false;} return v(ref_nested());
52379 struct Value_t : asn::typefield<true>
52381 ~Value_t() {clear();}
52382 size_t get_index() const {return type;}
52383 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
52384 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
52385 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
52386 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
52387 ResumeID& select_id_resumeID() { return set<ResumeID>(3); }
52388 ResumeID const* get_id_resumeID() const { return get<ResumeID>(3); }
52389 ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
52390 ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
52391 EUTRANCellIdentifier& select_id_NewEUTRANCellIdentifier() { return set<EUTRANCellIdentifier>(5); }
52392 EUTRANCellIdentifier const* get_id_NewEUTRANCellIdentifier() const { return get<EUTRANCellIdentifier>(5); }
52393 CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(6); }
52394 CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(6); }
52395 PCI& select_id_FailureCellPCI() { return set<PCI>(7); }
52396 PCI const* get_id_FailureCellPCI() const { return get<PCI>(7); }
52397 bool is_unknown() const { return type == 8; }
52402 case 1: var.destroy<UE_X2AP_ID>(); break;
52403 case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
52404 case 3: var.destroy<ResumeID>(); break;
52405 case 4: var.destroy<ShortMAC_I>(); break;
52406 case 5: var.destroy<EUTRANCellIdentifier>(); break;
52407 case 6: var.destroy<CRNTI>(); break;
52408 case 7: var.destroy<PCI>(); break;
52410 type = 0; ref_nested().clear();
52412 template<typename V> static inline void enumerate(V& v)
52414 v.template operator()<UE_X2AP_ID>(1);
52415 v.template operator()<UE_X2AP_ID_Extension>(2);
52416 v.template operator()<ResumeID>(3);
52417 v.template operator()<ShortMAC_I>(4);
52418 v.template operator()<EUTRANCellIdentifier>(5);
52419 v.template operator()<CRNTI>(6);
52420 v.template operator()<PCI>(7);
52424 template<typename V> bool decode(size_t index, V& v)
52429 case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
52430 case 2: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
52431 case 3: v(select_id_resumeID()); return true;
52432 case 4: v(select_id_ShortMAC_I()); return true;
52433 case 5: v(select_id_NewEUTRANCellIdentifier()); return true;
52434 case 6: v(select_id_FailureCellCRNTI()); return true;
52435 case 7: v(select_id_FailureCellPCI()); return true;
52436 case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
52441 template<typename V> bool encode(size_t index, V& v) const
52443 if(index != type) return false;
52446 case 1: v(var.as<UE_X2AP_ID>()); return true;
52447 case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
52448 case 3: v(var.as<ResumeID>()); return true;
52449 case 4: v(var.as<ShortMAC_I>()); return true;
52450 case 5: v(var.as<EUTRANCellIdentifier>()); return true;
52451 case 6: v(var.as<CRNTI>()); return true;
52452 case 7: v(var.as<PCI>()); return true;
52458 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52459 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52462 char dummy1[sizeof(CRNTI)];
52463 char dummy2[sizeof(EUTRANCellIdentifier)];
52464 char dummy3[sizeof(PCI)];
52465 char dummy4[sizeof(ResumeID)];
52466 char dummy5[sizeof(ShortMAC_I)];
52467 char dummy6[sizeof(UE_X2AP_ID)];
52468 char dummy7[sizeof(UE_X2AP_ID_Extension)];
52471 asn::variant<sizeof(union_type)> var;
52475 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
52477 size_t get_index() const {return type;}
52478 bool is_unknown() const { return type == 8; }
52479 void clear() {type = 0;}
52480 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
52481 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
52482 void select_id_resumeID() { set(mandatory); type=3;}
52483 void select_id_ShortMAC_I() { set(mandatory); type=4;}
52484 void select_id_NewEUTRANCellIdentifier() { set(mandatory); type=5;}
52485 void select_id_FailureCellCRNTI() { set(optional); type=6;}
52486 void select_id_FailureCellPCI() { set(optional); type=7;}
52487 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
52488 template<typename V> bool decode(V& v)
52491 if(!v(ref_nested())) return false;
52492 if(equal(mandatory)) { type = 1; return true; }
52493 else if(equal(optional)) { type = 2; return true; }
52494 else if(equal(mandatory)) { type = 3; return true; }
52495 else if(equal(mandatory)) { type = 4; return true; }
52496 else if(equal(mandatory)) { type = 5; return true; }
52497 else if(equal(optional)) { type = 6; return true; }
52498 else if(equal(optional)) { type = 7; return true; }
52499 else { type = 8; return true;}
52503 template<typename V> bool encode(V& v) const
52505 return v(ref_nested());
52509 template<typename V> bool decode(size_t index, V& v)
52514 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
52515 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
52516 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
52517 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
52518 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
52519 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
52520 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
52521 case 8: type = 8; return v(ref_nested());
52522 ref_nested().clear();
52527 template<typename V> bool encode(size_t index, V& v) const
52529 if(index != type) {return false;} return v(ref_nested());
52539 RetrieveUEContextRequest ::= SEQUENCE {
52540 protocolIEs ProtocolIE-Container {{ RetrieveUEContextRequest-IEs}},
52545 struct RetrieveUEContextRequest : asn::sequence<1, 0, true, 0>
52547 static constexpr const char* name() {return "RetrieveUEContextRequest";}
52548 using parent_t = asn::sequence<1, 0, true, 0>;
52549 struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextRequest_IEs>
52551 static constexpr const char* name() {return "protocolIEs_t";}
52552 using parent_t = ProtocolIE_Container<RetrieveUEContextRequest_IEs>;
52555 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
52556 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
52557 template<typename V> void decode(V& v)
52562 template<typename V> void encode(V& v) const
52569 protocolIEs.clear();
52573 protocolIEs_t protocolIEs;
52577 UE-ContextInformationRetrieve-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
52578 { ID id-UESidelinkAggregateMaximumBitRate CRITICALITY ignore EXTENSION UESidelinkAggregateMaximumBitRate PRESENCE optional},
52583 struct UE_ContextInformationRetrieve_ExtIEs
52585 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
52587 size_t get_index() const {return type;}
52588 bool is_unknown() const { return type == 2; }
52589 void clear() {type = 0;}
52590 void select_id_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); type=1;}
52591 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
52592 template<typename V> bool decode(V& v)
52595 if(!v(ref_nested())) return false;
52596 if(equal(id_UESidelinkAggregateMaximumBitRate)) { type = 1; return true; }
52597 else { type = 2; return true;}
52601 template<typename V> bool encode(V& v) const
52603 return v(ref_nested());
52607 template<typename V> bool decode(size_t index, V& v)
52612 case 1: type = 1; if(v(ref_nested())) { return equal(id_UESidelinkAggregateMaximumBitRate);} return false;
52613 case 2: type = 2; return v(ref_nested());
52614 ref_nested().clear();
52619 template<typename V> bool encode(size_t index, V& v) const
52621 if(index != type) {return false;} return v(ref_nested());
52628 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
52630 size_t get_index() const {return type;}
52631 bool is_unknown() const { return type == 2; }
52632 void clear() {type = 0;}
52633 void select_id_UESidelinkAggregateMaximumBitRate() { set(ignore); type=1;}
52634 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
52635 template<typename V> bool decode(V& v)
52638 if(!v(ref_nested())) return false;
52639 if(equal(ignore)) { type = 1; return true; }
52640 else { type = 2; return true;}
52644 template<typename V> bool encode(V& v) const
52646 return v(ref_nested());
52650 template<typename V> bool decode(size_t index, V& v)
52655 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
52656 case 2: type = 2; return v(ref_nested());
52657 ref_nested().clear();
52662 template<typename V> bool encode(size_t index, V& v) const
52664 if(index != type) {return false;} return v(ref_nested());
52671 struct Extension_t : asn::typefield<true>
52673 ~Extension_t() {clear();}
52674 size_t get_index() const {return type;}
52675 UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(1); }
52676 UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(1); }
52677 bool is_unknown() const { return type == 2; }
52682 case 1: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
52684 type = 0; ref_nested().clear();
52686 template<typename V> static inline void enumerate(V& v)
52688 v.template operator()<UESidelinkAggregateMaximumBitRate>(1);
52692 template<typename V> bool decode(size_t index, V& v)
52697 case 1: v(select_id_UESidelinkAggregateMaximumBitRate()); return true;
52698 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
52703 template<typename V> bool encode(size_t index, V& v) const
52705 if(index != type) return false;
52708 case 1: v(var.as<UESidelinkAggregateMaximumBitRate>()); return true;
52714 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52715 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52718 char dummy1[sizeof(UESidelinkAggregateMaximumBitRate)];
52721 asn::variant<sizeof(union_type)> var;
52725 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
52727 size_t get_index() const {return type;}
52728 bool is_unknown() const { return type == 2; }
52729 void clear() {type = 0;}
52730 void select_id_UESidelinkAggregateMaximumBitRate() { set(optional); type=1;}
52731 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
52732 template<typename V> bool decode(V& v)
52735 if(!v(ref_nested())) return false;
52736 if(equal(optional)) { type = 1; return true; }
52737 else { type = 2; return true;}
52741 template<typename V> bool encode(V& v) const
52743 return v(ref_nested());
52747 template<typename V> bool decode(size_t index, V& v)
52752 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
52753 case 2: type = 2; return v(ref_nested());
52754 ref_nested().clear();
52759 template<typename V> bool encode(size_t index, V& v) const
52761 if(index != type) {return false;} return v(ref_nested());
52771 UE-ContextInformationRetrieve ::= SEQUENCE {
52772 mME-UE-S1AP-ID UE-S1AP-ID,
52773 uESecurityCapabilities UESecurityCapabilities,
52774 aS-SecurityInformation AS-SecurityInformation,
52775 uEaggregateMaximumBitRate UEAggregateMaximumBitRate,
52776 subscriberProfileIDforRFP SubscriberProfileIDforRFP OPTIONAL,
52777 e-RABs-ToBeSetup-ListRetrieve E-RABs-ToBeSetup-ListRetrieve,
52778 rRC-Context RRC-Context,
52779 handoverRestrictionList HandoverRestrictionList OPTIONAL,
52780 locationReportingInformation LocationReportingInformation OPTIONAL,
52781 managBasedMDTallowed ManagementBasedMDTallowed OPTIONAL,
52782 managBasedMDTPLMNList MDTPLMNList OPTIONAL,
52783 iE-Extensions ProtocolExtensionContainer { {UE-ContextInformationRetrieve-ExtIEs} } OPTIONAL,
52788 struct UE_ContextInformationRetrieve : asn::sequence<12, 0, true, 6>
52790 static constexpr const char* name() {return "UE-ContextInformationRetrieve";}
52791 using parent_t = asn::sequence<12, 0, true, 6>;
52792 struct mME_UE_S1AP_ID_t : UE_S1AP_ID
52794 static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
52795 using parent_t = UE_S1AP_ID;
52798 mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
52799 mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
52800 struct uESecurityCapabilities_t : UESecurityCapabilities
52802 static constexpr const char* name() {return "uESecurityCapabilities_t";}
52803 using parent_t = UESecurityCapabilities;
52806 uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
52807 uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
52808 struct aS_SecurityInformation_t : AS_SecurityInformation
52810 static constexpr const char* name() {return "aS_SecurityInformation_t";}
52811 using parent_t = AS_SecurityInformation;
52814 aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
52815 aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
52816 struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
52818 static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
52819 using parent_t = UEAggregateMaximumBitRate;
52822 uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
52823 uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
52824 struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
52826 static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
52827 using parent_t = SubscriberProfileIDforRFP;
52828 static constexpr bool optional = true;
52831 subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
52832 subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
52833 struct e_RABs_ToBeSetup_ListRetrieve_t : E_RABs_ToBeSetup_ListRetrieve
52835 static constexpr const char* name() {return "e_RABs_ToBeSetup_ListRetrieve_t";}
52836 using parent_t = E_RABs_ToBeSetup_ListRetrieve;
52839 e_RABs_ToBeSetup_ListRetrieve_t& ref_e_RABs_ToBeSetup_ListRetrieve() {return e_RABs_ToBeSetup_ListRetrieve;}
52840 e_RABs_ToBeSetup_ListRetrieve_t const& ref_e_RABs_ToBeSetup_ListRetrieve() const {return e_RABs_ToBeSetup_ListRetrieve;}
52841 struct rRC_Context_t : RRC_Context
52843 static constexpr const char* name() {return "rRC_Context_t";}
52844 using parent_t = RRC_Context;
52847 rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
52848 rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
52849 struct handoverRestrictionList_t : HandoverRestrictionList
52851 static constexpr const char* name() {return "handoverRestrictionList_t";}
52852 using parent_t = HandoverRestrictionList;
52853 static constexpr bool optional = true;
52856 handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
52857 handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
52858 struct locationReportingInformation_t : LocationReportingInformation
52860 static constexpr const char* name() {return "locationReportingInformation_t";}
52861 using parent_t = LocationReportingInformation;
52862 static constexpr bool optional = true;
52865 locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
52866 locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
52867 struct managBasedMDTallowed_t : ManagementBasedMDTallowed
52869 static constexpr const char* name() {return "managBasedMDTallowed_t";}
52870 using parent_t = ManagementBasedMDTallowed;
52871 static constexpr bool optional = true;
52874 managBasedMDTallowed_t& set_managBasedMDTallowed() { managBasedMDTallowed.setpresent(true); return managBasedMDTallowed;}
52875 managBasedMDTallowed_t const* get_managBasedMDTallowed() const {return managBasedMDTallowed.is_valid() ? &managBasedMDTallowed : nullptr;}
52876 struct managBasedMDTPLMNList_t : MDTPLMNList
52878 static constexpr const char* name() {return "managBasedMDTPLMNList_t";}
52879 using parent_t = MDTPLMNList;
52880 static constexpr bool optional = true;
52883 managBasedMDTPLMNList_t& set_managBasedMDTPLMNList() { managBasedMDTPLMNList.setpresent(true); return managBasedMDTPLMNList;}
52884 managBasedMDTPLMNList_t const* get_managBasedMDTPLMNList() const {return managBasedMDTPLMNList.is_valid() ? &managBasedMDTPLMNList : nullptr;}
52885 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationRetrieve_ExtIEs>
52887 static constexpr const char* name() {return "iE_Extensions_t";}
52888 using parent_t = ProtocolExtensionContainer<UE_ContextInformationRetrieve_ExtIEs>;
52889 static constexpr bool optional = true;
52892 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
52893 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
52894 template<typename V> void decode(V& v)
52897 v(uESecurityCapabilities);
52898 v(aS_SecurityInformation);
52899 v(uEaggregateMaximumBitRate);
52900 v(subscriberProfileIDforRFP);
52901 v(e_RABs_ToBeSetup_ListRetrieve);
52903 v(handoverRestrictionList);
52904 v(locationReportingInformation);
52905 v(managBasedMDTallowed);
52906 v(managBasedMDTPLMNList);
52910 template<typename V> void encode(V& v) const
52913 v(uESecurityCapabilities);
52914 v(aS_SecurityInformation);
52915 v(uEaggregateMaximumBitRate);
52916 v(subscriberProfileIDforRFP);
52917 v(e_RABs_ToBeSetup_ListRetrieve);
52919 v(handoverRestrictionList);
52920 v(locationReportingInformation);
52921 v(managBasedMDTallowed);
52922 v(managBasedMDTPLMNList);
52928 mME_UE_S1AP_ID.clear();
52929 uESecurityCapabilities.clear();
52930 aS_SecurityInformation.clear();
52931 uEaggregateMaximumBitRate.clear();
52932 subscriberProfileIDforRFP.clear();
52933 e_RABs_ToBeSetup_ListRetrieve.clear();
52934 rRC_Context.clear();
52935 handoverRestrictionList.clear();
52936 locationReportingInformation.clear();
52937 managBasedMDTallowed.clear();
52938 managBasedMDTPLMNList.clear();
52939 iE_Extensions.clear();
52943 mME_UE_S1AP_ID_t mME_UE_S1AP_ID;
52944 uESecurityCapabilities_t uESecurityCapabilities;
52945 aS_SecurityInformation_t aS_SecurityInformation;
52946 uEaggregateMaximumBitRate_t uEaggregateMaximumBitRate;
52947 subscriberProfileIDforRFP_t subscriberProfileIDforRFP;
52948 e_RABs_ToBeSetup_ListRetrieve_t e_RABs_ToBeSetup_ListRetrieve;
52949 rRC_Context_t rRC_Context;
52950 handoverRestrictionList_t handoverRestrictionList;
52951 locationReportingInformation_t locationReportingInformation;
52952 managBasedMDTallowed_t managBasedMDTallowed;
52953 managBasedMDTPLMNList_t managBasedMDTPLMNList;
52954 iE_Extensions_t iE_Extensions;
52958 RetrieveUEContextResponse-IEs X2AP-PROTOCOL-IES ::= {
52959 { ID id-New-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
52960 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
52961 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
52962 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
52963 { ID id-GUMMEI-ID CRITICALITY reject TYPE GUMMEI PRESENCE mandatory}|
52964 { ID id-UE-ContextInformationRetrieve CRITICALITY reject TYPE UE-ContextInformationRetrieve PRESENCE mandatory}|
52965 { ID id-TraceActivation CRITICALITY ignore TYPE TraceActivation PRESENCE optional}|
52966 { ID id-SRVCCOperationPossible CRITICALITY ignore TYPE SRVCCOperationPossible PRESENCE optional}|
52967 { ID id-Masked-IMEISV CRITICALITY ignore TYPE Masked-IMEISV PRESENCE optional}|
52968 { ID id-ExpectedUEBehaviour CRITICALITY ignore TYPE ExpectedUEBehaviour PRESENCE optional}|
52969 { ID id-ProSeAuthorized CRITICALITY ignore TYPE ProSeAuthorized PRESENCE optional}|
52970 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
52971 { ID id-V2XServicesAuthorized CRITICALITY ignore TYPE V2XServicesAuthorized PRESENCE optional}|
52972 { ID id-AerialUEsubscriptionInformation CRITICALITY ignore TYPE AerialUEsubscriptionInformation PRESENCE optional}|
52973 { ID id-Subscription-Based-UE-DifferentiationInfo CRITICALITY ignore TYPE Subscription-Based-UE-DifferentiationInfo PRESENCE optional},
52978 struct RetrieveUEContextResponse_IEs
52980 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
52982 size_t get_index() const {return type;}
52983 bool is_unknown() const { return type == 16; }
52984 void clear() {type = 0;}
52985 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
52986 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
52987 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=3;}
52988 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
52989 void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=5;}
52990 void select_id_UE_ContextInformationRetrieve() { set(id_UE_ContextInformationRetrieve); type=6;}
52991 void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
52992 void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
52993 void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=9;}
52994 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
52995 void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=11;}
52996 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=12;}
52997 void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=13;}
52998 void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=14;}
52999 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=15;}
53000 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53001 template<typename V> bool decode(V& v)
53004 if(!v(ref_nested())) return false;
53005 if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
53006 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
53007 else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 3; return true; }
53008 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
53009 else if(equal(id_GUMMEI_ID)) { type = 5; return true; }
53010 else if(equal(id_UE_ContextInformationRetrieve)) { type = 6; return true; }
53011 else if(equal(id_TraceActivation)) { type = 7; return true; }
53012 else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
53013 else if(equal(id_Masked_IMEISV)) { type = 9; return true; }
53014 else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
53015 else if(equal(id_ProSeAuthorized)) { type = 11; return true; }
53016 else if(equal(id_CriticalityDiagnostics)) { type = 12; return true; }
53017 else if(equal(id_V2XServicesAuthorized)) { type = 13; return true; }
53018 else if(equal(id_AerialUEsubscriptionInformation)) { type = 14; return true; }
53019 else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 15; return true; }
53020 else { type = 16; return true;}
53024 template<typename V> bool encode(V& v) const
53026 return v(ref_nested());
53030 template<typename V> bool decode(size_t index, V& v)
53035 case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
53036 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
53037 case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
53038 case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
53039 case 5: type = 5; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
53040 case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationRetrieve);} return false;
53041 case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
53042 case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
53043 case 9: type = 9; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
53044 case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
53045 case 11: type = 11; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
53046 case 12: type = 12; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
53047 case 13: type = 13; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
53048 case 14: type = 14; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
53049 case 15: type = 15; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
53050 case 16: type = 16; return v(ref_nested());
53051 ref_nested().clear();
53056 template<typename V> bool encode(size_t index, V& v) const
53058 if(index != type) {return false;} return v(ref_nested());
53065 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53067 size_t get_index() const {return type;}
53068 bool is_unknown() const { return type == 16; }
53069 void clear() {type = 0;}
53070 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
53071 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
53072 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=3;}
53073 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
53074 void select_id_GUMMEI_ID() { set(reject); type=5;}
53075 void select_id_UE_ContextInformationRetrieve() { set(reject); type=6;}
53076 void select_id_TraceActivation() { set(ignore); type=7;}
53077 void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
53078 void select_id_Masked_IMEISV() { set(ignore); type=9;}
53079 void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
53080 void select_id_ProSeAuthorized() { set(ignore); type=11;}
53081 void select_id_CriticalityDiagnostics() { set(ignore); type=12;}
53082 void select_id_V2XServicesAuthorized() { set(ignore); type=13;}
53083 void select_id_AerialUEsubscriptionInformation() { set(ignore); type=14;}
53084 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=15;}
53085 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53086 template<typename V> bool decode(V& v)
53089 if(!v(ref_nested())) return false;
53090 if(equal(ignore)) { type = 1; return true; }
53091 else if(equal(ignore)) { type = 2; return true; }
53092 else if(equal(ignore)) { type = 3; return true; }
53093 else if(equal(ignore)) { type = 4; return true; }
53094 else if(equal(reject)) { type = 5; return true; }
53095 else if(equal(reject)) { type = 6; return true; }
53096 else if(equal(ignore)) { type = 7; return true; }
53097 else if(equal(ignore)) { type = 8; return true; }
53098 else if(equal(ignore)) { type = 9; return true; }
53099 else if(equal(ignore)) { type = 10; return true; }
53100 else if(equal(ignore)) { type = 11; return true; }
53101 else if(equal(ignore)) { type = 12; return true; }
53102 else if(equal(ignore)) { type = 13; return true; }
53103 else if(equal(ignore)) { type = 14; return true; }
53104 else if(equal(ignore)) { type = 15; return true; }
53105 else { type = 16; return true;}
53109 template<typename V> bool encode(V& v) const
53111 return v(ref_nested());
53115 template<typename V> bool decode(size_t index, V& v)
53120 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
53121 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
53122 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
53123 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
53124 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
53125 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
53126 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
53127 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
53128 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
53129 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
53130 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
53131 case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
53132 case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
53133 case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
53134 case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
53135 case 16: type = 16; return v(ref_nested());
53136 ref_nested().clear();
53141 template<typename V> bool encode(size_t index, V& v) const
53143 if(index != type) {return false;} return v(ref_nested());
53150 struct Value_t : asn::typefield<true>
53152 ~Value_t() {clear();}
53153 size_t get_index() const {return type;}
53154 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53155 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53156 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
53157 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
53158 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(3); }
53159 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(3); }
53160 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
53161 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
53162 GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(5); }
53163 GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(5); }
53164 UE_ContextInformationRetrieve& select_id_UE_ContextInformationRetrieve() { return set<UE_ContextInformationRetrieve>(6); }
53165 UE_ContextInformationRetrieve const* get_id_UE_ContextInformationRetrieve() const { return get<UE_ContextInformationRetrieve>(6); }
53166 TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
53167 TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
53168 SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
53169 SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
53170 Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(9); }
53171 Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(9); }
53172 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
53173 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
53174 ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(11); }
53175 ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(11); }
53176 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(12); }
53177 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(12); }
53178 V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(13); }
53179 V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(13); }
53180 AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(14); }
53181 AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(14); }
53182 Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(15); }
53183 Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(15); }
53184 bool is_unknown() const { return type == 16; }
53189 case 1: var.destroy<UE_X2AP_ID>(); break;
53190 case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
53191 case 3: var.destroy<UE_X2AP_ID>(); break;
53192 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
53193 case 5: var.destroy<GUMMEI>(); break;
53194 case 6: var.destroy<UE_ContextInformationRetrieve>(); break;
53195 case 7: var.destroy<TraceActivation>(); break;
53196 case 8: var.destroy<SRVCCOperationPossible>(); break;
53197 case 9: var.destroy<Masked_IMEISV>(); break;
53198 case 10: var.destroy<ExpectedUEBehaviour>(); break;
53199 case 11: var.destroy<ProSeAuthorized>(); break;
53200 case 12: var.destroy<CriticalityDiagnostics>(); break;
53201 case 13: var.destroy<V2XServicesAuthorized>(); break;
53202 case 14: var.destroy<AerialUEsubscriptionInformation>(); break;
53203 case 15: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
53205 type = 0; ref_nested().clear();
53207 template<typename V> static inline void enumerate(V& v)
53209 v.template operator()<UE_X2AP_ID>(1);
53210 v.template operator()<UE_X2AP_ID_Extension>(2);
53211 v.template operator()<UE_X2AP_ID>(3);
53212 v.template operator()<UE_X2AP_ID_Extension>(4);
53213 v.template operator()<GUMMEI>(5);
53214 v.template operator()<UE_ContextInformationRetrieve>(6);
53215 v.template operator()<TraceActivation>(7);
53216 v.template operator()<SRVCCOperationPossible>(8);
53217 v.template operator()<Masked_IMEISV>(9);
53218 v.template operator()<ExpectedUEBehaviour>(10);
53219 v.template operator()<ProSeAuthorized>(11);
53220 v.template operator()<CriticalityDiagnostics>(12);
53221 v.template operator()<V2XServicesAuthorized>(13);
53222 v.template operator()<AerialUEsubscriptionInformation>(14);
53223 v.template operator()<Subscription_Based_UE_DifferentiationInfo>(15);
53227 template<typename V> bool decode(size_t index, V& v)
53232 case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
53233 case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
53234 case 3: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
53235 case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
53236 case 5: v(select_id_GUMMEI_ID()); return true;
53237 case 6: v(select_id_UE_ContextInformationRetrieve()); return true;
53238 case 7: v(select_id_TraceActivation()); return true;
53239 case 8: v(select_id_SRVCCOperationPossible()); return true;
53240 case 9: v(select_id_Masked_IMEISV()); return true;
53241 case 10: v(select_id_ExpectedUEBehaviour()); return true;
53242 case 11: v(select_id_ProSeAuthorized()); return true;
53243 case 12: v(select_id_CriticalityDiagnostics()); return true;
53244 case 13: v(select_id_V2XServicesAuthorized()); return true;
53245 case 14: v(select_id_AerialUEsubscriptionInformation()); return true;
53246 case 15: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
53247 case 16: if(type != 16) {clear(); asn::base::set();} type = 16; return true;
53252 template<typename V> bool encode(size_t index, V& v) const
53254 if(index != type) return false;
53257 case 1: v(var.as<UE_X2AP_ID>()); return true;
53258 case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
53259 case 3: v(var.as<UE_X2AP_ID>()); return true;
53260 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
53261 case 5: v(var.as<GUMMEI>()); return true;
53262 case 6: v(var.as<UE_ContextInformationRetrieve>()); return true;
53263 case 7: v(var.as<TraceActivation>()); return true;
53264 case 8: v(var.as<SRVCCOperationPossible>()); return true;
53265 case 9: v(var.as<Masked_IMEISV>()); return true;
53266 case 10: v(var.as<ExpectedUEBehaviour>()); return true;
53267 case 11: v(var.as<ProSeAuthorized>()); return true;
53268 case 12: v(var.as<CriticalityDiagnostics>()); return true;
53269 case 13: v(var.as<V2XServicesAuthorized>()); return true;
53270 case 14: v(var.as<AerialUEsubscriptionInformation>()); return true;
53271 case 15: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); return true;
53277 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
53278 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
53281 char dummy1[sizeof(AerialUEsubscriptionInformation)];
53282 char dummy2[sizeof(CriticalityDiagnostics)];
53283 char dummy3[sizeof(ExpectedUEBehaviour)];
53284 char dummy4[sizeof(GUMMEI)];
53285 char dummy5[sizeof(Masked_IMEISV)];
53286 char dummy6[sizeof(ProSeAuthorized)];
53287 char dummy7[sizeof(SRVCCOperationPossible)];
53288 char dummy8[sizeof(Subscription_Based_UE_DifferentiationInfo)];
53289 char dummy9[sizeof(TraceActivation)];
53290 char dummy10[sizeof(UE_ContextInformationRetrieve)];
53291 char dummy11[sizeof(UE_X2AP_ID)];
53292 char dummy12[sizeof(UE_X2AP_ID_Extension)];
53293 char dummy13[sizeof(V2XServicesAuthorized)];
53296 asn::variant<sizeof(union_type)> var;
53300 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
53302 size_t get_index() const {return type;}
53303 bool is_unknown() const { return type == 16; }
53304 void clear() {type = 0;}
53305 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
53306 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
53307 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=3;}
53308 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
53309 void select_id_GUMMEI_ID() { set(mandatory); type=5;}
53310 void select_id_UE_ContextInformationRetrieve() { set(mandatory); type=6;}
53311 void select_id_TraceActivation() { set(optional); type=7;}
53312 void select_id_SRVCCOperationPossible() { set(optional); type=8;}
53313 void select_id_Masked_IMEISV() { set(optional); type=9;}
53314 void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
53315 void select_id_ProSeAuthorized() { set(optional); type=11;}
53316 void select_id_CriticalityDiagnostics() { set(optional); type=12;}
53317 void select_id_V2XServicesAuthorized() { set(optional); type=13;}
53318 void select_id_AerialUEsubscriptionInformation() { set(optional); type=14;}
53319 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=15;}
53320 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
53321 template<typename V> bool decode(V& v)
53324 if(!v(ref_nested())) return false;
53325 if(equal(mandatory)) { type = 1; return true; }
53326 else if(equal(optional)) { type = 2; return true; }
53327 else if(equal(mandatory)) { type = 3; return true; }
53328 else if(equal(optional)) { type = 4; return true; }
53329 else if(equal(mandatory)) { type = 5; return true; }
53330 else if(equal(mandatory)) { type = 6; return true; }
53331 else if(equal(optional)) { type = 7; return true; }
53332 else if(equal(optional)) { type = 8; return true; }
53333 else if(equal(optional)) { type = 9; return true; }
53334 else if(equal(optional)) { type = 10; return true; }
53335 else if(equal(optional)) { type = 11; return true; }
53336 else if(equal(optional)) { type = 12; return true; }
53337 else if(equal(optional)) { type = 13; return true; }
53338 else if(equal(optional)) { type = 14; return true; }
53339 else if(equal(optional)) { type = 15; return true; }
53340 else { type = 16; return true;}
53344 template<typename V> bool encode(V& v) const
53346 return v(ref_nested());
53350 template<typename V> bool decode(size_t index, V& v)
53355 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
53356 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
53357 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
53358 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
53359 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
53360 case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
53361 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
53362 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
53363 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
53364 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
53365 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
53366 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
53367 case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
53368 case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
53369 case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
53370 case 16: type = 16; return v(ref_nested());
53371 ref_nested().clear();
53376 template<typename V> bool encode(size_t index, V& v) const
53378 if(index != type) {return false;} return v(ref_nested());
53388 RetrieveUEContextResponse ::= SEQUENCE {
53389 protocolIEs ProtocolIE-Container {{ RetrieveUEContextResponse-IEs}},
53394 struct RetrieveUEContextResponse : asn::sequence<1, 0, true, 0>
53396 static constexpr const char* name() {return "RetrieveUEContextResponse";}
53397 using parent_t = asn::sequence<1, 0, true, 0>;
53398 struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextResponse_IEs>
53400 static constexpr const char* name() {return "protocolIEs_t";}
53401 using parent_t = ProtocolIE_Container<RetrieveUEContextResponse_IEs>;
53404 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
53405 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
53406 template<typename V> void decode(V& v)
53411 template<typename V> void encode(V& v) const
53418 protocolIEs.clear();
53422 protocolIEs_t protocolIEs;
53426 SNStatusTransfer-IEs X2AP-PROTOCOL-IES ::= {
53427 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
53428 { ID id-New-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
53429 { ID id-E-RABs-SubjectToStatusTransfer-List CRITICALITY ignore TYPE E-RABs-SubjectToStatusTransfer-List PRESENCE mandatory}|
53430 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
53431 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
53432 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE optional},
53437 struct SNStatusTransfer_IEs
53439 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
53441 size_t get_index() const {return type;}
53442 bool is_unknown() const { return type == 7; }
53443 void clear() {type = 0;}
53444 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
53445 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
53446 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(id_E_RABs_SubjectToStatusTransfer_List); type=3;}
53447 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
53448 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
53449 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
53450 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53451 template<typename V> bool decode(V& v)
53454 if(!v(ref_nested())) return false;
53455 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
53456 else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
53457 else if(equal(id_E_RABs_SubjectToStatusTransfer_List)) { type = 3; return true; }
53458 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
53459 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
53460 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 6; return true; }
53461 else { type = 7; return true;}
53465 template<typename V> bool encode(V& v) const
53467 return v(ref_nested());
53471 template<typename V> bool decode(size_t index, V& v)
53476 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
53477 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
53478 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToStatusTransfer_List);} return false;
53479 case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
53480 case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
53481 case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
53482 case 7: type = 7; return v(ref_nested());
53483 ref_nested().clear();
53488 template<typename V> bool encode(size_t index, V& v) const
53490 if(index != type) {return false;} return v(ref_nested());
53497 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53499 size_t get_index() const {return type;}
53500 bool is_unknown() const { return type == 7; }
53501 void clear() {type = 0;}
53502 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
53503 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
53504 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(ignore); type=3;}
53505 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
53506 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
53507 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
53508 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53509 template<typename V> bool decode(V& v)
53512 if(!v(ref_nested())) return false;
53513 if(equal(reject)) { type = 1; return true; }
53514 else if(equal(reject)) { type = 2; return true; }
53515 else if(equal(ignore)) { type = 3; return true; }
53516 else if(equal(reject)) { type = 4; return true; }
53517 else if(equal(reject)) { type = 5; return true; }
53518 else if(equal(ignore)) { type = 6; return true; }
53519 else { type = 7; return true;}
53523 template<typename V> bool encode(V& v) const
53525 return v(ref_nested());
53529 template<typename V> bool decode(size_t index, V& v)
53534 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
53535 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
53536 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
53537 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
53538 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
53539 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
53540 case 7: type = 7; return v(ref_nested());
53541 ref_nested().clear();
53546 template<typename V> bool encode(size_t index, V& v) const
53548 if(index != type) {return false;} return v(ref_nested());
53555 struct Value_t : asn::typefield<true>
53557 ~Value_t() {clear();}
53558 size_t get_index() const {return type;}
53559 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53560 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53561 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
53562 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
53563 E_RABs_SubjectToStatusTransfer_List& select_id_E_RABs_SubjectToStatusTransfer_List() { return set<E_RABs_SubjectToStatusTransfer_List>(3); }
53564 E_RABs_SubjectToStatusTransfer_List const* get_id_E_RABs_SubjectToStatusTransfer_List() const { return get<E_RABs_SubjectToStatusTransfer_List>(3); }
53565 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
53566 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
53567 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
53568 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
53569 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
53570 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
53571 bool is_unknown() const { return type == 7; }
53576 case 1: var.destroy<UE_X2AP_ID>(); break;
53577 case 2: var.destroy<UE_X2AP_ID>(); break;
53578 case 3: var.destroy<E_RABs_SubjectToStatusTransfer_List>(); break;
53579 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
53580 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
53581 case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
53583 type = 0; ref_nested().clear();
53585 template<typename V> static inline void enumerate(V& v)
53587 v.template operator()<UE_X2AP_ID>(1);
53588 v.template operator()<UE_X2AP_ID>(2);
53589 v.template operator()<E_RABs_SubjectToStatusTransfer_List>(3);
53590 v.template operator()<UE_X2AP_ID_Extension>(4);
53591 v.template operator()<UE_X2AP_ID_Extension>(5);
53592 v.template operator()<SgNB_UE_X2AP_ID>(6);
53596 template<typename V> bool decode(size_t index, V& v)
53601 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
53602 case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
53603 case 3: v(select_id_E_RABs_SubjectToStatusTransfer_List()); return true;
53604 case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
53605 case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
53606 case 6: v(select_id_SgNB_UE_X2AP_ID()); return true;
53607 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
53612 template<typename V> bool encode(size_t index, V& v) const
53614 if(index != type) return false;
53617 case 1: v(var.as<UE_X2AP_ID>()); return true;
53618 case 2: v(var.as<UE_X2AP_ID>()); return true;
53619 case 3: v(var.as<E_RABs_SubjectToStatusTransfer_List>()); return true;
53620 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
53621 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
53622 case 6: v(var.as<SgNB_UE_X2AP_ID>()); return true;
53628 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
53629 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
53632 char dummy1[sizeof(E_RABs_SubjectToStatusTransfer_List)];
53633 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
53634 char dummy3[sizeof(UE_X2AP_ID)];
53635 char dummy4[sizeof(UE_X2AP_ID_Extension)];
53638 asn::variant<sizeof(union_type)> var;
53642 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
53644 size_t get_index() const {return type;}
53645 bool is_unknown() const { return type == 7; }
53646 void clear() {type = 0;}
53647 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
53648 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
53649 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(mandatory); type=3;}
53650 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
53651 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
53652 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
53653 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
53654 template<typename V> bool decode(V& v)
53657 if(!v(ref_nested())) return false;
53658 if(equal(mandatory)) { type = 1; return true; }
53659 else if(equal(mandatory)) { type = 2; return true; }
53660 else if(equal(mandatory)) { type = 3; return true; }
53661 else if(equal(optional)) { type = 4; return true; }
53662 else if(equal(optional)) { type = 5; return true; }
53663 else if(equal(optional)) { type = 6; return true; }
53664 else { type = 7; return true;}
53668 template<typename V> bool encode(V& v) const
53670 return v(ref_nested());
53674 template<typename V> bool decode(size_t index, V& v)
53679 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
53680 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
53681 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
53682 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
53683 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
53684 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
53685 case 7: type = 7; return v(ref_nested());
53686 ref_nested().clear();
53691 template<typename V> bool encode(size_t index, V& v) const
53693 if(index != type) {return false;} return v(ref_nested());
53703 SNStatusTransfer ::= SEQUENCE {
53704 protocolIEs ProtocolIE-Container {{SNStatusTransfer-IEs}},
53709 struct SNStatusTransfer : asn::sequence<1, 0, true, 0>
53711 static constexpr const char* name() {return "SNStatusTransfer";}
53712 using parent_t = asn::sequence<1, 0, true, 0>;
53713 struct protocolIEs_t : ProtocolIE_Container<SNStatusTransfer_IEs>
53715 static constexpr const char* name() {return "protocolIEs_t";}
53716 using parent_t = ProtocolIE_Container<SNStatusTransfer_IEs>;
53719 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
53720 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
53721 template<typename V> void decode(V& v)
53726 template<typename V> void encode(V& v) const
53733 protocolIEs.clear();
53737 protocolIEs_t protocolIEs;
53741 SeNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
53742 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
53743 { ID id-UE-SecurityCapabilities CRITICALITY reject TYPE UESecurityCapabilities PRESENCE conditional}|
53744 -- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
53745 { ID id-SeNBSecurityKey CRITICALITY reject TYPE SeNBSecurityKey PRESENCE conditional}|
53746 -- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
53747 { ID id-SeNBUEAggregateMaximumBitRate CRITICALITY reject TYPE UEAggregateMaximumBitRate PRESENCE mandatory}|
53748 { ID id-ServingPLMN CRITICALITY ignore TYPE PLMN-Identity PRESENCE optional}|
53749 { ID id-E-RABs-ToBeAdded-List CRITICALITY reject TYPE E-RABs-ToBeAdded-List PRESENCE mandatory}|
53750 { ID id-MeNBtoSeNBContainer CRITICALITY reject TYPE MeNBtoSeNBContainer PRESENCE mandatory}|
53751 { ID id-CSGMembershipStatus CRITICALITY reject TYPE CSGMembershipStatus PRESENCE optional}|
53752 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE optional}|
53753 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
53754 { ID id-ExpectedUEBehaviour CRITICALITY ignore TYPE ExpectedUEBehaviour PRESENCE optional}|
53755 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
53760 struct SeNBAdditionRequest_IEs
53762 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
53764 size_t get_index() const {return type;}
53765 bool is_unknown() const { return type == 13; }
53766 void clear() {type = 0;}
53767 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
53768 void select_id_UE_SecurityCapabilities() { set(id_UE_SecurityCapabilities); type=2;}
53769 void select_id_SeNBSecurityKey() { set(id_SeNBSecurityKey); type=3;}
53770 void select_id_SeNBUEAggregateMaximumBitRate() { set(id_SeNBUEAggregateMaximumBitRate); type=4;}
53771 void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
53772 void select_id_E_RABs_ToBeAdded_List() { set(id_E_RABs_ToBeAdded_List); type=6;}
53773 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
53774 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
53775 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=9;}
53776 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
53777 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=11;}
53778 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=12;}
53779 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53780 template<typename V> bool decode(V& v)
53783 if(!v(ref_nested())) return false;
53784 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
53785 else if(equal(id_UE_SecurityCapabilities)) { type = 2; return true; }
53786 else if(equal(id_SeNBSecurityKey)) { type = 3; return true; }
53787 else if(equal(id_SeNBUEAggregateMaximumBitRate)) { type = 4; return true; }
53788 else if(equal(id_ServingPLMN)) { type = 5; return true; }
53789 else if(equal(id_E_RABs_ToBeAdded_List)) { type = 6; return true; }
53790 else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
53791 else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
53792 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 9; return true; }
53793 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
53794 else if(equal(id_ExpectedUEBehaviour)) { type = 11; return true; }
53795 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 12; return true; }
53796 else { type = 13; return true;}
53800 template<typename V> bool encode(V& v) const
53802 return v(ref_nested());
53806 template<typename V> bool decode(size_t index, V& v)
53811 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
53812 case 2: type = 2; if(v(ref_nested())) { return equal(id_UE_SecurityCapabilities);} return false;
53813 case 3: type = 3; if(v(ref_nested())) { return equal(id_SeNBSecurityKey);} return false;
53814 case 4: type = 4; if(v(ref_nested())) { return equal(id_SeNBUEAggregateMaximumBitRate);} return false;
53815 case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
53816 case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_List);} return false;
53817 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
53818 case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
53819 case 9: type = 9; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
53820 case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
53821 case 11: type = 11; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
53822 case 12: type = 12; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
53823 case 13: type = 13; return v(ref_nested());
53824 ref_nested().clear();
53829 template<typename V> bool encode(size_t index, V& v) const
53831 if(index != type) {return false;} return v(ref_nested());
53838 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53840 size_t get_index() const {return type;}
53841 bool is_unknown() const { return type == 13; }
53842 void clear() {type = 0;}
53843 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
53844 void select_id_UE_SecurityCapabilities() { set(reject); type=2;}
53845 void select_id_SeNBSecurityKey() { set(reject); type=3;}
53846 void select_id_SeNBUEAggregateMaximumBitRate() { set(reject); type=4;}
53847 void select_id_ServingPLMN() { set(ignore); type=5;}
53848 void select_id_E_RABs_ToBeAdded_List() { set(reject); type=6;}
53849 void select_id_MeNBtoSeNBContainer() { set(reject); type=7;}
53850 void select_id_CSGMembershipStatus() { set(reject); type=8;}
53851 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=9;}
53852 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
53853 void select_id_ExpectedUEBehaviour() { set(ignore); type=11;}
53854 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=12;}
53855 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53856 template<typename V> bool decode(V& v)
53859 if(!v(ref_nested())) return false;
53860 if(equal(reject)) { type = 1; return true; }
53861 else if(equal(reject)) { type = 2; return true; }
53862 else if(equal(reject)) { type = 3; return true; }
53863 else if(equal(reject)) { type = 4; return true; }
53864 else if(equal(ignore)) { type = 5; return true; }
53865 else if(equal(reject)) { type = 6; return true; }
53866 else if(equal(reject)) { type = 7; return true; }
53867 else if(equal(reject)) { type = 8; return true; }
53868 else if(equal(reject)) { type = 9; return true; }
53869 else if(equal(reject)) { type = 10; return true; }
53870 else if(equal(ignore)) { type = 11; return true; }
53871 else if(equal(reject)) { type = 12; return true; }
53872 else { type = 13; return true;}
53876 template<typename V> bool encode(V& v) const
53878 return v(ref_nested());
53882 template<typename V> bool decode(size_t index, V& v)
53887 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
53888 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
53889 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
53890 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
53891 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
53892 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
53893 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
53894 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
53895 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
53896 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
53897 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
53898 case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
53899 case 13: type = 13; return v(ref_nested());
53900 ref_nested().clear();
53905 template<typename V> bool encode(size_t index, V& v) const
53907 if(index != type) {return false;} return v(ref_nested());
53914 struct Value_t : asn::typefield<true>
53916 ~Value_t() {clear();}
53917 size_t get_index() const {return type;}
53918 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53919 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53920 UESecurityCapabilities& select_id_UE_SecurityCapabilities() { return set<UESecurityCapabilities>(2); }
53921 UESecurityCapabilities const* get_id_UE_SecurityCapabilities() const { return get<UESecurityCapabilities>(2); }
53922 SeNBSecurityKey& select_id_SeNBSecurityKey() { return set<SeNBSecurityKey>(3); }
53923 SeNBSecurityKey const* get_id_SeNBSecurityKey() const { return get<SeNBSecurityKey>(3); }
53924 UEAggregateMaximumBitRate& select_id_SeNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
53925 UEAggregateMaximumBitRate const* get_id_SeNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
53926 PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
53927 PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
53928 E_RABs_ToBeAdded_List& select_id_E_RABs_ToBeAdded_List() { return set<E_RABs_ToBeAdded_List>(6); }
53929 E_RABs_ToBeAdded_List const* get_id_E_RABs_ToBeAdded_List() const { return get<E_RABs_ToBeAdded_List>(6); }
53930 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
53931 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
53932 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
53933 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
53934 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(9); }
53935 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(9); }
53936 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
53937 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
53938 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(11); }
53939 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(11); }
53940 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(12); }
53941 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(12); }
53942 bool is_unknown() const { return type == 13; }
53947 case 1: var.destroy<UE_X2AP_ID>(); break;
53948 case 2: var.destroy<UESecurityCapabilities>(); break;
53949 case 3: var.destroy<SeNBSecurityKey>(); break;
53950 case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
53951 case 5: var.destroy<PLMN_Identity>(); break;
53952 case 6: var.destroy<E_RABs_ToBeAdded_List>(); break;
53953 case 7: var.destroy<MeNBtoSeNBContainer>(); break;
53954 case 8: var.destroy<CSGMembershipStatus>(); break;
53955 case 9: var.destroy<UE_X2AP_ID>(); break;
53956 case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
53957 case 11: var.destroy<ExpectedUEBehaviour>(); break;
53958 case 12: var.destroy<UE_X2AP_ID_Extension>(); break;
53960 type = 0; ref_nested().clear();
53962 template<typename V> static inline void enumerate(V& v)
53964 v.template operator()<UE_X2AP_ID>(1);
53965 v.template operator()<UESecurityCapabilities>(2);
53966 v.template operator()<SeNBSecurityKey>(3);
53967 v.template operator()<UEAggregateMaximumBitRate>(4);
53968 v.template operator()<PLMN_Identity>(5);
53969 v.template operator()<E_RABs_ToBeAdded_List>(6);
53970 v.template operator()<MeNBtoSeNBContainer>(7);
53971 v.template operator()<CSGMembershipStatus>(8);
53972 v.template operator()<UE_X2AP_ID>(9);
53973 v.template operator()<UE_X2AP_ID_Extension>(10);
53974 v.template operator()<ExpectedUEBehaviour>(11);
53975 v.template operator()<UE_X2AP_ID_Extension>(12);
53979 template<typename V> bool decode(size_t index, V& v)
53984 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
53985 case 2: v(select_id_UE_SecurityCapabilities()); return true;
53986 case 3: v(select_id_SeNBSecurityKey()); return true;
53987 case 4: v(select_id_SeNBUEAggregateMaximumBitRate()); return true;
53988 case 5: v(select_id_ServingPLMN()); return true;
53989 case 6: v(select_id_E_RABs_ToBeAdded_List()); return true;
53990 case 7: v(select_id_MeNBtoSeNBContainer()); return true;
53991 case 8: v(select_id_CSGMembershipStatus()); return true;
53992 case 9: v(select_id_SeNB_UE_X2AP_ID()); return true;
53993 case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
53994 case 11: v(select_id_ExpectedUEBehaviour()); return true;
53995 case 12: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
53996 case 13: if(type != 13) {clear(); asn::base::set();} type = 13; return true;
54001 template<typename V> bool encode(size_t index, V& v) const
54003 if(index != type) return false;
54006 case 1: v(var.as<UE_X2AP_ID>()); return true;
54007 case 2: v(var.as<UESecurityCapabilities>()); return true;
54008 case 3: v(var.as<SeNBSecurityKey>()); return true;
54009 case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
54010 case 5: v(var.as<PLMN_Identity>()); return true;
54011 case 6: v(var.as<E_RABs_ToBeAdded_List>()); return true;
54012 case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
54013 case 8: v(var.as<CSGMembershipStatus>()); return true;
54014 case 9: v(var.as<UE_X2AP_ID>()); return true;
54015 case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
54016 case 11: v(var.as<ExpectedUEBehaviour>()); return true;
54017 case 12: v(var.as<UE_X2AP_ID_Extension>()); return true;
54023 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54024 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54027 char dummy1[sizeof(CSGMembershipStatus)];
54028 char dummy2[sizeof(E_RABs_ToBeAdded_List)];
54029 char dummy3[sizeof(ExpectedUEBehaviour)];
54030 char dummy4[sizeof(MeNBtoSeNBContainer)];
54031 char dummy5[sizeof(PLMN_Identity)];
54032 char dummy6[sizeof(SeNBSecurityKey)];
54033 char dummy7[sizeof(UEAggregateMaximumBitRate)];
54034 char dummy8[sizeof(UESecurityCapabilities)];
54035 char dummy9[sizeof(UE_X2AP_ID)];
54036 char dummy10[sizeof(UE_X2AP_ID_Extension)];
54039 asn::variant<sizeof(union_type)> var;
54043 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54045 size_t get_index() const {return type;}
54046 bool is_unknown() const { return type == 13; }
54047 void clear() {type = 0;}
54048 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54049 void select_id_UE_SecurityCapabilities() { set(conditional); type=2;}
54050 void select_id_SeNBSecurityKey() { set(conditional); type=3;}
54051 void select_id_SeNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
54052 void select_id_ServingPLMN() { set(optional); type=5;}
54053 void select_id_E_RABs_ToBeAdded_List() { set(mandatory); type=6;}
54054 void select_id_MeNBtoSeNBContainer() { set(mandatory); type=7;}
54055 void select_id_CSGMembershipStatus() { set(optional); type=8;}
54056 void select_id_SeNB_UE_X2AP_ID() { set(optional); type=9;}
54057 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
54058 void select_id_ExpectedUEBehaviour() { set(optional); type=11;}
54059 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=12;}
54060 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54061 template<typename V> bool decode(V& v)
54064 if(!v(ref_nested())) return false;
54065 if(equal(mandatory)) { type = 1; return true; }
54066 else if(equal(conditional)) { type = 2; return true; }
54067 else if(equal(conditional)) { type = 3; return true; }
54068 else if(equal(mandatory)) { type = 4; return true; }
54069 else if(equal(optional)) { type = 5; return true; }
54070 else if(equal(mandatory)) { type = 6; return true; }
54071 else if(equal(mandatory)) { type = 7; return true; }
54072 else if(equal(optional)) { type = 8; return true; }
54073 else if(equal(optional)) { type = 9; return true; }
54074 else if(equal(optional)) { type = 10; return true; }
54075 else if(equal(optional)) { type = 11; return true; }
54076 else if(equal(optional)) { type = 12; return true; }
54077 else { type = 13; return true;}
54081 template<typename V> bool encode(V& v) const
54083 return v(ref_nested());
54087 template<typename V> bool decode(size_t index, V& v)
54092 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54093 case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
54094 case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
54095 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
54096 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
54097 case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
54098 case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} return false;
54099 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
54100 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
54101 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
54102 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
54103 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
54104 case 13: type = 13; return v(ref_nested());
54105 ref_nested().clear();
54110 template<typename V> bool encode(size_t index, V& v) const
54112 if(index != type) {return false;} return v(ref_nested());
54122 SeNBAdditionRequest ::= SEQUENCE {
54123 protocolIEs ProtocolIE-Container {{SeNBAdditionRequest-IEs}},
54128 struct SeNBAdditionRequest : asn::sequence<1, 0, true, 0>
54130 static constexpr const char* name() {return "SeNBAdditionRequest";}
54131 using parent_t = asn::sequence<1, 0, true, 0>;
54132 struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequest_IEs>
54134 static constexpr const char* name() {return "protocolIEs_t";}
54135 using parent_t = ProtocolIE_Container<SeNBAdditionRequest_IEs>;
54138 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54139 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54140 template<typename V> void decode(V& v)
54145 template<typename V> void encode(V& v) const
54152 protocolIEs.clear();
54156 protocolIEs_t protocolIEs;
54160 SeNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
54161 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54162 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54163 { ID id-E-RABs-Admitted-ToBeAdded-List CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-List PRESENCE mandatory}|
54164 { ID id-E-RABs-NotAdmitted-List CRITICALITY ignore TYPE E-RAB-List PRESENCE optional}|
54165 { ID id-SeNBtoMeNBContainer CRITICALITY reject TYPE SeNBtoMeNBContainer PRESENCE mandatory}|
54166 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
54167 { ID id-GW-TransportLayerAddress CRITICALITY ignore TYPE TransportLayerAddress PRESENCE optional}|
54168 { ID id-SIPTO-L-GW-TransportLayerAddress CRITICALITY ignore TYPE TransportLayerAddress PRESENCE optional}|
54169 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
54170 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
54171 { ID id-Tunnel-Information-for-BBF CRITICALITY ignore TYPE TunnelInformation PRESENCE optional},
54176 struct SeNBAdditionRequestAcknowledge_IEs
54178 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54180 size_t get_index() const {return type;}
54181 bool is_unknown() const { return type == 12; }
54182 void clear() {type = 0;}
54183 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54184 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54185 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(id_E_RABs_Admitted_ToBeAdded_List); type=3;}
54186 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
54187 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=5;}
54188 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
54189 void select_id_GW_TransportLayerAddress() { set(id_GW_TransportLayerAddress); type=7;}
54190 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(id_SIPTO_L_GW_TransportLayerAddress); type=8;}
54191 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
54192 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
54193 void select_id_Tunnel_Information_for_BBF() { set(id_Tunnel_Information_for_BBF); type=11;}
54194 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54195 template<typename V> bool decode(V& v)
54198 if(!v(ref_nested())) return false;
54199 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54200 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54201 else if(equal(id_E_RABs_Admitted_ToBeAdded_List)) { type = 3; return true; }
54202 else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
54203 else if(equal(id_SeNBtoMeNBContainer)) { type = 5; return true; }
54204 else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
54205 else if(equal(id_GW_TransportLayerAddress)) { type = 7; return true; }
54206 else if(equal(id_SIPTO_L_GW_TransportLayerAddress)) { type = 8; return true; }
54207 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
54208 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
54209 else if(equal(id_Tunnel_Information_for_BBF)) { type = 11; return true; }
54210 else { type = 12; return true;}
54214 template<typename V> bool encode(V& v) const
54216 return v(ref_nested());
54220 template<typename V> bool decode(size_t index, V& v)
54225 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54226 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54227 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_List);} return false;
54228 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
54229 case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
54230 case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
54231 case 7: type = 7; if(v(ref_nested())) { return equal(id_GW_TransportLayerAddress);} return false;
54232 case 8: type = 8; if(v(ref_nested())) { return equal(id_SIPTO_L_GW_TransportLayerAddress);} return false;
54233 case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54234 case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54235 case 11: type = 11; if(v(ref_nested())) { return equal(id_Tunnel_Information_for_BBF);} return false;
54236 case 12: type = 12; return v(ref_nested());
54237 ref_nested().clear();
54242 template<typename V> bool encode(size_t index, V& v) const
54244 if(index != type) {return false;} return v(ref_nested());
54251 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54253 size_t get_index() const {return type;}
54254 bool is_unknown() const { return type == 12; }
54255 void clear() {type = 0;}
54256 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54257 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54258 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(ignore); type=3;}
54259 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
54260 void select_id_SeNBtoMeNBContainer() { set(reject); type=5;}
54261 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
54262 void select_id_GW_TransportLayerAddress() { set(ignore); type=7;}
54263 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(ignore); type=8;}
54264 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
54265 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
54266 void select_id_Tunnel_Information_for_BBF() { set(ignore); type=11;}
54267 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54268 template<typename V> bool decode(V& v)
54271 if(!v(ref_nested())) return false;
54272 if(equal(reject)) { type = 1; return true; }
54273 else if(equal(reject)) { type = 2; return true; }
54274 else if(equal(ignore)) { type = 3; return true; }
54275 else if(equal(ignore)) { type = 4; return true; }
54276 else if(equal(reject)) { type = 5; return true; }
54277 else if(equal(ignore)) { type = 6; return true; }
54278 else if(equal(ignore)) { type = 7; return true; }
54279 else if(equal(ignore)) { type = 8; return true; }
54280 else if(equal(reject)) { type = 9; return true; }
54281 else if(equal(reject)) { type = 10; return true; }
54282 else if(equal(ignore)) { type = 11; return true; }
54283 else { type = 12; return true;}
54287 template<typename V> bool encode(V& v) const
54289 return v(ref_nested());
54293 template<typename V> bool decode(size_t index, V& v)
54298 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54299 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54300 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54301 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54302 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
54303 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
54304 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
54305 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
54306 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
54307 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
54308 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
54309 case 12: type = 12; return v(ref_nested());
54310 ref_nested().clear();
54315 template<typename V> bool encode(size_t index, V& v) const
54317 if(index != type) {return false;} return v(ref_nested());
54324 struct Value_t : asn::typefield<true>
54326 ~Value_t() {clear();}
54327 size_t get_index() const {return type;}
54328 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
54329 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
54330 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
54331 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
54332 E_RABs_Admitted_ToBeAdded_List& select_id_E_RABs_Admitted_ToBeAdded_List() { return set<E_RABs_Admitted_ToBeAdded_List>(3); }
54333 E_RABs_Admitted_ToBeAdded_List const* get_id_E_RABs_Admitted_ToBeAdded_List() const { return get<E_RABs_Admitted_ToBeAdded_List>(3); }
54334 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
54335 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
54336 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(5); }
54337 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(5); }
54338 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
54339 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
54340 TransportLayerAddress& select_id_GW_TransportLayerAddress() { return set<TransportLayerAddress>(7); }
54341 TransportLayerAddress const* get_id_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(7); }
54342 TransportLayerAddress& select_id_SIPTO_L_GW_TransportLayerAddress() { return set<TransportLayerAddress>(8); }
54343 TransportLayerAddress const* get_id_SIPTO_L_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(8); }
54344 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
54345 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
54346 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
54347 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
54348 TunnelInformation& select_id_Tunnel_Information_for_BBF() { return set<TunnelInformation>(11); }
54349 TunnelInformation const* get_id_Tunnel_Information_for_BBF() const { return get<TunnelInformation>(11); }
54350 bool is_unknown() const { return type == 12; }
54355 case 1: var.destroy<UE_X2AP_ID>(); break;
54356 case 2: var.destroy<UE_X2AP_ID>(); break;
54357 case 3: var.destroy<E_RABs_Admitted_ToBeAdded_List>(); break;
54358 case 4: var.destroy<E_RAB_List>(); break;
54359 case 5: var.destroy<SeNBtoMeNBContainer>(); break;
54360 case 6: var.destroy<CriticalityDiagnostics>(); break;
54361 case 7: var.destroy<TransportLayerAddress>(); break;
54362 case 8: var.destroy<TransportLayerAddress>(); break;
54363 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
54364 case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
54365 case 11: var.destroy<TunnelInformation>(); break;
54367 type = 0; ref_nested().clear();
54369 template<typename V> static inline void enumerate(V& v)
54371 v.template operator()<UE_X2AP_ID>(1);
54372 v.template operator()<UE_X2AP_ID>(2);
54373 v.template operator()<E_RABs_Admitted_ToBeAdded_List>(3);
54374 v.template operator()<E_RAB_List>(4);
54375 v.template operator()<SeNBtoMeNBContainer>(5);
54376 v.template operator()<CriticalityDiagnostics>(6);
54377 v.template operator()<TransportLayerAddress>(7);
54378 v.template operator()<TransportLayerAddress>(8);
54379 v.template operator()<UE_X2AP_ID_Extension>(9);
54380 v.template operator()<UE_X2AP_ID_Extension>(10);
54381 v.template operator()<TunnelInformation>(11);
54385 template<typename V> bool decode(size_t index, V& v)
54390 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
54391 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
54392 case 3: v(select_id_E_RABs_Admitted_ToBeAdded_List()); return true;
54393 case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
54394 case 5: v(select_id_SeNBtoMeNBContainer()); return true;
54395 case 6: v(select_id_CriticalityDiagnostics()); return true;
54396 case 7: v(select_id_GW_TransportLayerAddress()); return true;
54397 case 8: v(select_id_SIPTO_L_GW_TransportLayerAddress()); return true;
54398 case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
54399 case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
54400 case 11: v(select_id_Tunnel_Information_for_BBF()); return true;
54401 case 12: if(type != 12) {clear(); asn::base::set();} type = 12; return true;
54406 template<typename V> bool encode(size_t index, V& v) const
54408 if(index != type) return false;
54411 case 1: v(var.as<UE_X2AP_ID>()); return true;
54412 case 2: v(var.as<UE_X2AP_ID>()); return true;
54413 case 3: v(var.as<E_RABs_Admitted_ToBeAdded_List>()); return true;
54414 case 4: v(var.as<E_RAB_List>()); return true;
54415 case 5: v(var.as<SeNBtoMeNBContainer>()); return true;
54416 case 6: v(var.as<CriticalityDiagnostics>()); return true;
54417 case 7: v(var.as<TransportLayerAddress>()); return true;
54418 case 8: v(var.as<TransportLayerAddress>()); return true;
54419 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
54420 case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
54421 case 11: v(var.as<TunnelInformation>()); return true;
54427 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54428 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54431 char dummy1[sizeof(CriticalityDiagnostics)];
54432 char dummy2[sizeof(E_RAB_List)];
54433 char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_List)];
54434 char dummy4[sizeof(SeNBtoMeNBContainer)];
54435 char dummy5[sizeof(TransportLayerAddress)];
54436 char dummy6[sizeof(TunnelInformation)];
54437 char dummy7[sizeof(UE_X2AP_ID)];
54438 char dummy8[sizeof(UE_X2AP_ID_Extension)];
54441 asn::variant<sizeof(union_type)> var;
54445 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54447 size_t get_index() const {return type;}
54448 bool is_unknown() const { return type == 12; }
54449 void clear() {type = 0;}
54450 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54451 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
54452 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(mandatory); type=3;}
54453 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
54454 void select_id_SeNBtoMeNBContainer() { set(mandatory); type=5;}
54455 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
54456 void select_id_GW_TransportLayerAddress() { set(optional); type=7;}
54457 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(optional); type=8;}
54458 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
54459 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
54460 void select_id_Tunnel_Information_for_BBF() { set(optional); type=11;}
54461 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54462 template<typename V> bool decode(V& v)
54465 if(!v(ref_nested())) return false;
54466 if(equal(mandatory)) { type = 1; return true; }
54467 else if(equal(mandatory)) { type = 2; return true; }
54468 else if(equal(mandatory)) { type = 3; return true; }
54469 else if(equal(optional)) { type = 4; return true; }
54470 else if(equal(mandatory)) { type = 5; return true; }
54471 else if(equal(optional)) { type = 6; return true; }
54472 else if(equal(optional)) { type = 7; return true; }
54473 else if(equal(optional)) { type = 8; return true; }
54474 else if(equal(optional)) { type = 9; return true; }
54475 else if(equal(optional)) { type = 10; return true; }
54476 else if(equal(optional)) { type = 11; return true; }
54477 else { type = 12; return true;}
54481 template<typename V> bool encode(V& v) const
54483 return v(ref_nested());
54487 template<typename V> bool decode(size_t index, V& v)
54492 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54493 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
54494 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
54495 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
54496 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
54497 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
54498 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
54499 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
54500 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
54501 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
54502 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
54503 case 12: type = 12; return v(ref_nested());
54504 ref_nested().clear();
54509 template<typename V> bool encode(size_t index, V& v) const
54511 if(index != type) {return false;} return v(ref_nested());
54521 SeNBAdditionRequestAcknowledge ::= SEQUENCE {
54522 protocolIEs ProtocolIE-Container {{SeNBAdditionRequestAcknowledge-IEs}},
54527 struct SeNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
54529 static constexpr const char* name() {return "SeNBAdditionRequestAcknowledge";}
54530 using parent_t = asn::sequence<1, 0, true, 0>;
54531 struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>
54533 static constexpr const char* name() {return "protocolIEs_t";}
54534 using parent_t = ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>;
54537 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54538 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54539 template<typename V> void decode(V& v)
54544 template<typename V> void encode(V& v) const
54551 protocolIEs.clear();
54555 protocolIEs_t protocolIEs;
54559 SeNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
54560 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54561 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54562 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
54563 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
54564 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
54565 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
54570 struct SeNBAdditionRequestReject_IEs
54572 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54574 size_t get_index() const {return type;}
54575 bool is_unknown() const { return type == 7; }
54576 void clear() {type = 0;}
54577 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54578 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54579 void select_id_Cause() { set(id_Cause); type=3;}
54580 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
54581 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
54582 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
54583 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54584 template<typename V> bool decode(V& v)
54587 if(!v(ref_nested())) return false;
54588 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54589 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54590 else if(equal(id_Cause)) { type = 3; return true; }
54591 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
54592 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
54593 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
54594 else { type = 7; return true;}
54598 template<typename V> bool encode(V& v) const
54600 return v(ref_nested());
54604 template<typename V> bool decode(size_t index, V& v)
54609 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54610 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54611 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
54612 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
54613 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54614 case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54615 case 7: type = 7; return v(ref_nested());
54616 ref_nested().clear();
54621 template<typename V> bool encode(size_t index, V& v) const
54623 if(index != type) {return false;} return v(ref_nested());
54630 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54632 size_t get_index() const {return type;}
54633 bool is_unknown() const { return type == 7; }
54634 void clear() {type = 0;}
54635 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54636 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54637 void select_id_Cause() { set(ignore); type=3;}
54638 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
54639 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
54640 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
54641 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54642 template<typename V> bool decode(V& v)
54645 if(!v(ref_nested())) return false;
54646 if(equal(reject)) { type = 1; return true; }
54647 else if(equal(reject)) { type = 2; return true; }
54648 else if(equal(ignore)) { type = 3; return true; }
54649 else if(equal(ignore)) { type = 4; return true; }
54650 else if(equal(reject)) { type = 5; return true; }
54651 else if(equal(reject)) { type = 6; return true; }
54652 else { type = 7; return true;}
54656 template<typename V> bool encode(V& v) const
54658 return v(ref_nested());
54662 template<typename V> bool decode(size_t index, V& v)
54667 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54668 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54669 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54670 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54671 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
54672 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
54673 case 7: type = 7; return v(ref_nested());
54674 ref_nested().clear();
54679 template<typename V> bool encode(size_t index, V& v) const
54681 if(index != type) {return false;} return v(ref_nested());
54688 struct Value_t : asn::typefield<true>
54690 ~Value_t() {clear();}
54691 size_t get_index() const {return type;}
54692 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
54693 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
54694 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
54695 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
54696 Cause& select_id_Cause() { return set<Cause>(3); }
54697 Cause const* get_id_Cause() const { return get<Cause>(3); }
54698 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
54699 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
54700 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
54701 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
54702 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
54703 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
54704 bool is_unknown() const { return type == 7; }
54709 case 1: var.destroy<UE_X2AP_ID>(); break;
54710 case 2: var.destroy<UE_X2AP_ID>(); break;
54711 case 3: var.destroy<Cause>(); break;
54712 case 4: var.destroy<CriticalityDiagnostics>(); break;
54713 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
54714 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
54716 type = 0; ref_nested().clear();
54718 template<typename V> static inline void enumerate(V& v)
54720 v.template operator()<UE_X2AP_ID>(1);
54721 v.template operator()<UE_X2AP_ID>(2);
54722 v.template operator()<Cause>(3);
54723 v.template operator()<CriticalityDiagnostics>(4);
54724 v.template operator()<UE_X2AP_ID_Extension>(5);
54725 v.template operator()<UE_X2AP_ID_Extension>(6);
54729 template<typename V> bool decode(size_t index, V& v)
54734 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
54735 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
54736 case 3: v(select_id_Cause()); return true;
54737 case 4: v(select_id_CriticalityDiagnostics()); return true;
54738 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
54739 case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
54740 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
54745 template<typename V> bool encode(size_t index, V& v) const
54747 if(index != type) return false;
54750 case 1: v(var.as<UE_X2AP_ID>()); return true;
54751 case 2: v(var.as<UE_X2AP_ID>()); return true;
54752 case 3: v(var.as<Cause>()); return true;
54753 case 4: v(var.as<CriticalityDiagnostics>()); return true;
54754 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
54755 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
54761 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54762 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54765 char dummy1[sizeof(Cause)];
54766 char dummy2[sizeof(CriticalityDiagnostics)];
54767 char dummy3[sizeof(UE_X2AP_ID)];
54768 char dummy4[sizeof(UE_X2AP_ID_Extension)];
54771 asn::variant<sizeof(union_type)> var;
54775 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54777 size_t get_index() const {return type;}
54778 bool is_unknown() const { return type == 7; }
54779 void clear() {type = 0;}
54780 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54781 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
54782 void select_id_Cause() { set(mandatory); type=3;}
54783 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
54784 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
54785 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
54786 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54787 template<typename V> bool decode(V& v)
54790 if(!v(ref_nested())) return false;
54791 if(equal(mandatory)) { type = 1; return true; }
54792 else if(equal(mandatory)) { type = 2; return true; }
54793 else if(equal(mandatory)) { type = 3; return true; }
54794 else if(equal(optional)) { type = 4; return true; }
54795 else if(equal(optional)) { type = 5; return true; }
54796 else if(equal(optional)) { type = 6; return true; }
54797 else { type = 7; return true;}
54801 template<typename V> bool encode(V& v) const
54803 return v(ref_nested());
54807 template<typename V> bool decode(size_t index, V& v)
54812 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54813 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
54814 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
54815 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
54816 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
54817 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
54818 case 7: type = 7; return v(ref_nested());
54819 ref_nested().clear();
54824 template<typename V> bool encode(size_t index, V& v) const
54826 if(index != type) {return false;} return v(ref_nested());
54836 SeNBAdditionRequestReject ::= SEQUENCE {
54837 protocolIEs ProtocolIE-Container {{SeNBAdditionRequestReject-IEs}},
54842 struct SeNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
54844 static constexpr const char* name() {return "SeNBAdditionRequestReject";}
54845 using parent_t = asn::sequence<1, 0, true, 0>;
54846 struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestReject_IEs>
54848 static constexpr const char* name() {return "protocolIEs_t";}
54849 using parent_t = ProtocolIE_Container<SeNBAdditionRequestReject_IEs>;
54852 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54853 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54854 template<typename V> void decode(V& v)
54859 template<typename V> void encode(V& v) const
54866 protocolIEs.clear();
54870 protocolIEs_t protocolIEs;
54874 SeNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
54875 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54876 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
54877 { ID id-E-RABs-SubjectToCounterCheck-List CRITICALITY ignore TYPE E-RABs-SubjectToCounterCheck-List PRESENCE mandatory}|
54878 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
54879 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
54884 struct SeNBCounterCheckRequest_IEs
54886 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54888 size_t get_index() const {return type;}
54889 bool is_unknown() const { return type == 6; }
54890 void clear() {type = 0;}
54891 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54892 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54893 void select_id_E_RABs_SubjectToCounterCheck_List() { set(id_E_RABs_SubjectToCounterCheck_List); type=3;}
54894 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
54895 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
54896 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54897 template<typename V> bool decode(V& v)
54900 if(!v(ref_nested())) return false;
54901 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54902 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54903 else if(equal(id_E_RABs_SubjectToCounterCheck_List)) { type = 3; return true; }
54904 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
54905 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
54906 else { type = 6; return true;}
54910 template<typename V> bool encode(V& v) const
54912 return v(ref_nested());
54916 template<typename V> bool decode(size_t index, V& v)
54921 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54922 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54923 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToCounterCheck_List);} return false;
54924 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54925 case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54926 case 6: type = 6; return v(ref_nested());
54927 ref_nested().clear();
54932 template<typename V> bool encode(size_t index, V& v) const
54934 if(index != type) {return false;} return v(ref_nested());
54941 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54943 size_t get_index() const {return type;}
54944 bool is_unknown() const { return type == 6; }
54945 void clear() {type = 0;}
54946 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54947 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54948 void select_id_E_RABs_SubjectToCounterCheck_List() { set(ignore); type=3;}
54949 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
54950 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
54951 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54952 template<typename V> bool decode(V& v)
54955 if(!v(ref_nested())) return false;
54956 if(equal(reject)) { type = 1; return true; }
54957 else if(equal(reject)) { type = 2; return true; }
54958 else if(equal(ignore)) { type = 3; return true; }
54959 else if(equal(ignore)) { type = 4; return true; }
54960 else if(equal(ignore)) { type = 5; return true; }
54961 else { type = 6; return true;}
54965 template<typename V> bool encode(V& v) const
54967 return v(ref_nested());
54971 template<typename V> bool decode(size_t index, V& v)
54976 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54977 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54978 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54979 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54980 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
54981 case 6: type = 6; return v(ref_nested());
54982 ref_nested().clear();
54987 template<typename V> bool encode(size_t index, V& v) const
54989 if(index != type) {return false;} return v(ref_nested());
54996 struct Value_t : asn::typefield<true>
54998 ~Value_t() {clear();}
54999 size_t get_index() const {return type;}
55000 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55001 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55002 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55003 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55004 E_RABs_SubjectToCounterCheck_List& select_id_E_RABs_SubjectToCounterCheck_List() { return set<E_RABs_SubjectToCounterCheck_List>(3); }
55005 E_RABs_SubjectToCounterCheck_List const* get_id_E_RABs_SubjectToCounterCheck_List() const { return get<E_RABs_SubjectToCounterCheck_List>(3); }
55006 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
55007 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
55008 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
55009 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
55010 bool is_unknown() const { return type == 6; }
55015 case 1: var.destroy<UE_X2AP_ID>(); break;
55016 case 2: var.destroy<UE_X2AP_ID>(); break;
55017 case 3: var.destroy<E_RABs_SubjectToCounterCheck_List>(); break;
55018 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
55019 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
55021 type = 0; ref_nested().clear();
55023 template<typename V> static inline void enumerate(V& v)
55025 v.template operator()<UE_X2AP_ID>(1);
55026 v.template operator()<UE_X2AP_ID>(2);
55027 v.template operator()<E_RABs_SubjectToCounterCheck_List>(3);
55028 v.template operator()<UE_X2AP_ID_Extension>(4);
55029 v.template operator()<UE_X2AP_ID_Extension>(5);
55033 template<typename V> bool decode(size_t index, V& v)
55038 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55039 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55040 case 3: v(select_id_E_RABs_SubjectToCounterCheck_List()); return true;
55041 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55042 case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55043 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
55048 template<typename V> bool encode(size_t index, V& v) const
55050 if(index != type) return false;
55053 case 1: v(var.as<UE_X2AP_ID>()); return true;
55054 case 2: v(var.as<UE_X2AP_ID>()); return true;
55055 case 3: v(var.as<E_RABs_SubjectToCounterCheck_List>()); return true;
55056 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
55057 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
55063 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55064 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55067 char dummy1[sizeof(E_RABs_SubjectToCounterCheck_List)];
55068 char dummy2[sizeof(UE_X2AP_ID)];
55069 char dummy3[sizeof(UE_X2AP_ID_Extension)];
55072 asn::variant<sizeof(union_type)> var;
55076 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55078 size_t get_index() const {return type;}
55079 bool is_unknown() const { return type == 6; }
55080 void clear() {type = 0;}
55081 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55082 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55083 void select_id_E_RABs_SubjectToCounterCheck_List() { set(mandatory); type=3;}
55084 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
55085 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
55086 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55087 template<typename V> bool decode(V& v)
55090 if(!v(ref_nested())) return false;
55091 if(equal(mandatory)) { type = 1; return true; }
55092 else if(equal(mandatory)) { type = 2; return true; }
55093 else if(equal(mandatory)) { type = 3; return true; }
55094 else if(equal(optional)) { type = 4; return true; }
55095 else if(equal(optional)) { type = 5; return true; }
55096 else { type = 6; return true;}
55100 template<typename V> bool encode(V& v) const
55102 return v(ref_nested());
55106 template<typename V> bool decode(size_t index, V& v)
55111 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55112 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55113 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
55114 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55115 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55116 case 6: type = 6; return v(ref_nested());
55117 ref_nested().clear();
55122 template<typename V> bool encode(size_t index, V& v) const
55124 if(index != type) {return false;} return v(ref_nested());
55134 SeNBCounterCheckRequest ::= SEQUENCE {
55135 protocolIEs ProtocolIE-Container {{SeNBCounterCheckRequest-IEs}},
55140 struct SeNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
55142 static constexpr const char* name() {return "SeNBCounterCheckRequest";}
55143 using parent_t = asn::sequence<1, 0, true, 0>;
55144 struct protocolIEs_t : ProtocolIE_Container<SeNBCounterCheckRequest_IEs>
55146 static constexpr const char* name() {return "protocolIEs_t";}
55147 using parent_t = ProtocolIE_Container<SeNBCounterCheckRequest_IEs>;
55150 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55151 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55152 template<typename V> void decode(V& v)
55157 template<typename V> void encode(V& v) const
55164 protocolIEs.clear();
55168 protocolIEs_t protocolIEs;
55172 SeNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
55173 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
55174 { ID id-SeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
55175 { ID id-MeNBtoSeNBContainer CRITICALITY ignore TYPE MeNBtoSeNBContainer PRESENCE optional}|
55176 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
55177 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
55178 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
55183 struct SeNBModificationConfirm_IEs
55185 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
55187 size_t get_index() const {return type;}
55188 bool is_unknown() const { return type == 7; }
55189 void clear() {type = 0;}
55190 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
55191 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
55192 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=3;}
55193 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
55194 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
55195 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
55196 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
55197 template<typename V> bool decode(V& v)
55200 if(!v(ref_nested())) return false;
55201 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
55202 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
55203 else if(equal(id_MeNBtoSeNBContainer)) { type = 3; return true; }
55204 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
55205 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
55206 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
55207 else { type = 7; return true;}
55211 template<typename V> bool encode(V& v) const
55213 return v(ref_nested());
55217 template<typename V> bool decode(size_t index, V& v)
55222 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
55223 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
55224 case 3: type = 3; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
55225 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
55226 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
55227 case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
55228 case 7: type = 7; return v(ref_nested());
55229 ref_nested().clear();
55234 template<typename V> bool encode(size_t index, V& v) const
55236 if(index != type) {return false;} return v(ref_nested());
55243 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
55245 size_t get_index() const {return type;}
55246 bool is_unknown() const { return type == 7; }
55247 void clear() {type = 0;}
55248 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
55249 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
55250 void select_id_MeNBtoSeNBContainer() { set(ignore); type=3;}
55251 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
55252 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
55253 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
55254 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
55255 template<typename V> bool decode(V& v)
55258 if(!v(ref_nested())) return false;
55259 if(equal(ignore)) { type = 1; return true; }
55260 else if(equal(ignore)) { type = 2; return true; }
55261 else if(equal(ignore)) { type = 3; return true; }
55262 else if(equal(ignore)) { type = 4; return true; }
55263 else if(equal(ignore)) { type = 5; return true; }
55264 else if(equal(ignore)) { type = 6; return true; }
55265 else { type = 7; return true;}
55269 template<typename V> bool encode(V& v) const
55271 return v(ref_nested());
55275 template<typename V> bool decode(size_t index, V& v)
55280 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
55281 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
55282 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
55283 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
55284 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
55285 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
55286 case 7: type = 7; return v(ref_nested());
55287 ref_nested().clear();
55292 template<typename V> bool encode(size_t index, V& v) const
55294 if(index != type) {return false;} return v(ref_nested());
55301 struct Value_t : asn::typefield<true>
55303 ~Value_t() {clear();}
55304 size_t get_index() const {return type;}
55305 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55306 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55307 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55308 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55309 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(3); }
55310 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(3); }
55311 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
55312 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
55313 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
55314 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
55315 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
55316 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
55317 bool is_unknown() const { return type == 7; }
55322 case 1: var.destroy<UE_X2AP_ID>(); break;
55323 case 2: var.destroy<UE_X2AP_ID>(); break;
55324 case 3: var.destroy<MeNBtoSeNBContainer>(); break;
55325 case 4: var.destroy<CriticalityDiagnostics>(); break;
55326 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
55327 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
55329 type = 0; ref_nested().clear();
55331 template<typename V> static inline void enumerate(V& v)
55333 v.template operator()<UE_X2AP_ID>(1);
55334 v.template operator()<UE_X2AP_ID>(2);
55335 v.template operator()<MeNBtoSeNBContainer>(3);
55336 v.template operator()<CriticalityDiagnostics>(4);
55337 v.template operator()<UE_X2AP_ID_Extension>(5);
55338 v.template operator()<UE_X2AP_ID_Extension>(6);
55342 template<typename V> bool decode(size_t index, V& v)
55347 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55348 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55349 case 3: v(select_id_MeNBtoSeNBContainer()); return true;
55350 case 4: v(select_id_CriticalityDiagnostics()); return true;
55351 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55352 case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55353 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
55358 template<typename V> bool encode(size_t index, V& v) const
55360 if(index != type) return false;
55363 case 1: v(var.as<UE_X2AP_ID>()); return true;
55364 case 2: v(var.as<UE_X2AP_ID>()); return true;
55365 case 3: v(var.as<MeNBtoSeNBContainer>()); return true;
55366 case 4: v(var.as<CriticalityDiagnostics>()); return true;
55367 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
55368 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
55374 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55375 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55378 char dummy1[sizeof(CriticalityDiagnostics)];
55379 char dummy2[sizeof(MeNBtoSeNBContainer)];
55380 char dummy3[sizeof(UE_X2AP_ID)];
55381 char dummy4[sizeof(UE_X2AP_ID_Extension)];
55384 asn::variant<sizeof(union_type)> var;
55388 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55390 size_t get_index() const {return type;}
55391 bool is_unknown() const { return type == 7; }
55392 void clear() {type = 0;}
55393 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55394 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55395 void select_id_MeNBtoSeNBContainer() { set(optional); type=3;}
55396 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
55397 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
55398 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
55399 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55400 template<typename V> bool decode(V& v)
55403 if(!v(ref_nested())) return false;
55404 if(equal(mandatory)) { type = 1; return true; }
55405 else if(equal(mandatory)) { type = 2; return true; }
55406 else if(equal(optional)) { type = 3; return true; }
55407 else if(equal(optional)) { type = 4; return true; }
55408 else if(equal(optional)) { type = 5; return true; }
55409 else if(equal(optional)) { type = 6; return true; }
55410 else { type = 7; return true;}
55414 template<typename V> bool encode(V& v) const
55416 return v(ref_nested());
55420 template<typename V> bool decode(size_t index, V& v)
55425 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55426 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55427 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
55428 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55429 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55430 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
55431 case 7: type = 7; return v(ref_nested());
55432 ref_nested().clear();
55437 template<typename V> bool encode(size_t index, V& v) const
55439 if(index != type) {return false;} return v(ref_nested());
55449 SeNBModificationConfirm ::= SEQUENCE {
55450 protocolIEs ProtocolIE-Container {{SeNBModificationConfirm-IEs}},
55455 struct SeNBModificationConfirm : asn::sequence<1, 0, true, 0>
55457 static constexpr const char* name() {return "SeNBModificationConfirm";}
55458 using parent_t = asn::sequence<1, 0, true, 0>;
55459 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationConfirm_IEs>
55461 static constexpr const char* name() {return "protocolIEs_t";}
55462 using parent_t = ProtocolIE_Container<SeNBModificationConfirm_IEs>;
55465 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55466 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55467 template<typename V> void decode(V& v)
55472 template<typename V> void encode(V& v) const
55479 protocolIEs.clear();
55483 protocolIEs_t protocolIEs;
55487 SeNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
55488 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
55489 { ID id-SeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
55490 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
55491 { ID id-MeNBtoSeNBContainer CRITICALITY ignore TYPE MeNBtoSeNBContainer PRESENCE optional}|
55492 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
55493 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
55494 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
55499 struct SeNBModificationRefuse_IEs
55501 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
55503 size_t get_index() const {return type;}
55504 bool is_unknown() const { return type == 8; }
55505 void clear() {type = 0;}
55506 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
55507 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
55508 void select_id_Cause() { set(id_Cause); type=3;}
55509 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=4;}
55510 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
55511 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
55512 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
55513 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
55514 template<typename V> bool decode(V& v)
55517 if(!v(ref_nested())) return false;
55518 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
55519 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
55520 else if(equal(id_Cause)) { type = 3; return true; }
55521 else if(equal(id_MeNBtoSeNBContainer)) { type = 4; return true; }
55522 else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
55523 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
55524 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
55525 else { type = 8; return true;}
55529 template<typename V> bool encode(V& v) const
55531 return v(ref_nested());
55535 template<typename V> bool decode(size_t index, V& v)
55540 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
55541 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
55542 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
55543 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
55544 case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
55545 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
55546 case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
55547 case 8: type = 8; return v(ref_nested());
55548 ref_nested().clear();
55553 template<typename V> bool encode(size_t index, V& v) const
55555 if(index != type) {return false;} return v(ref_nested());
55562 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
55564 size_t get_index() const {return type;}
55565 bool is_unknown() const { return type == 8; }
55566 void clear() {type = 0;}
55567 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
55568 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
55569 void select_id_Cause() { set(ignore); type=3;}
55570 void select_id_MeNBtoSeNBContainer() { set(ignore); type=4;}
55571 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
55572 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
55573 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=7;}
55574 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
55575 template<typename V> bool decode(V& v)
55578 if(!v(ref_nested())) return false;
55579 if(equal(ignore)) { type = 1; return true; }
55580 else if(equal(ignore)) { type = 2; return true; }
55581 else if(equal(ignore)) { type = 3; return true; }
55582 else if(equal(ignore)) { type = 4; return true; }
55583 else if(equal(ignore)) { type = 5; return true; }
55584 else if(equal(ignore)) { type = 6; return true; }
55585 else if(equal(ignore)) { type = 7; return true; }
55586 else { type = 8; return true;}
55590 template<typename V> bool encode(V& v) const
55592 return v(ref_nested());
55596 template<typename V> bool decode(size_t index, V& v)
55601 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
55602 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
55603 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
55604 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
55605 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
55606 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
55607 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
55608 case 8: type = 8; return v(ref_nested());
55609 ref_nested().clear();
55614 template<typename V> bool encode(size_t index, V& v) const
55616 if(index != type) {return false;} return v(ref_nested());
55623 struct Value_t : asn::typefield<true>
55625 ~Value_t() {clear();}
55626 size_t get_index() const {return type;}
55627 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55628 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55629 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55630 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55631 Cause& select_id_Cause() { return set<Cause>(3); }
55632 Cause const* get_id_Cause() const { return get<Cause>(3); }
55633 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(4); }
55634 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(4); }
55635 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
55636 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
55637 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
55638 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
55639 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
55640 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
55641 bool is_unknown() const { return type == 8; }
55646 case 1: var.destroy<UE_X2AP_ID>(); break;
55647 case 2: var.destroy<UE_X2AP_ID>(); break;
55648 case 3: var.destroy<Cause>(); break;
55649 case 4: var.destroy<MeNBtoSeNBContainer>(); break;
55650 case 5: var.destroy<CriticalityDiagnostics>(); break;
55651 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
55652 case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
55654 type = 0; ref_nested().clear();
55656 template<typename V> static inline void enumerate(V& v)
55658 v.template operator()<UE_X2AP_ID>(1);
55659 v.template operator()<UE_X2AP_ID>(2);
55660 v.template operator()<Cause>(3);
55661 v.template operator()<MeNBtoSeNBContainer>(4);
55662 v.template operator()<CriticalityDiagnostics>(5);
55663 v.template operator()<UE_X2AP_ID_Extension>(6);
55664 v.template operator()<UE_X2AP_ID_Extension>(7);
55668 template<typename V> bool decode(size_t index, V& v)
55673 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55674 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55675 case 3: v(select_id_Cause()); return true;
55676 case 4: v(select_id_MeNBtoSeNBContainer()); return true;
55677 case 5: v(select_id_CriticalityDiagnostics()); return true;
55678 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55679 case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55680 case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
55685 template<typename V> bool encode(size_t index, V& v) const
55687 if(index != type) return false;
55690 case 1: v(var.as<UE_X2AP_ID>()); return true;
55691 case 2: v(var.as<UE_X2AP_ID>()); return true;
55692 case 3: v(var.as<Cause>()); return true;
55693 case 4: v(var.as<MeNBtoSeNBContainer>()); return true;
55694 case 5: v(var.as<CriticalityDiagnostics>()); return true;
55695 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
55696 case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
55702 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55703 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55706 char dummy1[sizeof(Cause)];
55707 char dummy2[sizeof(CriticalityDiagnostics)];
55708 char dummy3[sizeof(MeNBtoSeNBContainer)];
55709 char dummy4[sizeof(UE_X2AP_ID)];
55710 char dummy5[sizeof(UE_X2AP_ID_Extension)];
55713 asn::variant<sizeof(union_type)> var;
55717 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55719 size_t get_index() const {return type;}
55720 bool is_unknown() const { return type == 8; }
55721 void clear() {type = 0;}
55722 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55723 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55724 void select_id_Cause() { set(mandatory); type=3;}
55725 void select_id_MeNBtoSeNBContainer() { set(optional); type=4;}
55726 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
55727 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
55728 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
55729 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55730 template<typename V> bool decode(V& v)
55733 if(!v(ref_nested())) return false;
55734 if(equal(mandatory)) { type = 1; return true; }
55735 else if(equal(mandatory)) { type = 2; return true; }
55736 else if(equal(mandatory)) { type = 3; return true; }
55737 else if(equal(optional)) { type = 4; return true; }
55738 else if(equal(optional)) { type = 5; return true; }
55739 else if(equal(optional)) { type = 6; return true; }
55740 else if(equal(optional)) { type = 7; return true; }
55741 else { type = 8; return true;}
55745 template<typename V> bool encode(V& v) const
55747 return v(ref_nested());
55751 template<typename V> bool decode(size_t index, V& v)
55756 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55757 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55758 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
55759 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55760 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55761 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
55762 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
55763 case 8: type = 8; return v(ref_nested());
55764 ref_nested().clear();
55769 template<typename V> bool encode(size_t index, V& v) const
55771 if(index != type) {return false;} return v(ref_nested());
55781 SeNBModificationRefuse ::= SEQUENCE {
55782 protocolIEs ProtocolIE-Container {{SeNBModificationRefuse-IEs}},
55787 struct SeNBModificationRefuse : asn::sequence<1, 0, true, 0>
55789 static constexpr const char* name() {return "SeNBModificationRefuse";}
55790 using parent_t = asn::sequence<1, 0, true, 0>;
55791 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRefuse_IEs>
55793 static constexpr const char* name() {return "protocolIEs_t";}
55794 using parent_t = ProtocolIE_Container<SeNBModificationRefuse_IEs>;
55797 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55798 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55799 template<typename V> void decode(V& v)
55804 template<typename V> void encode(V& v) const
55811 protocolIEs.clear();
55815 protocolIEs_t protocolIEs;
55819 UE-ContextInformationSeNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
55824 struct UE_ContextInformationSeNBModReqExtIEs
55826 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
55828 size_t get_index() const {return type;}
55829 bool is_unknown() const { return type == 1; }
55830 void clear() {type = 0;}
55831 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
55832 template<typename V> bool decode(V& v)
55835 if(!v(ref_nested())) return false;
55836 { type = 1; return true;}
55840 template<typename V> bool encode(V& v) const
55842 return v(ref_nested());
55846 template<typename V> bool decode(size_t index, V& v)
55851 case 1: type = 1; return v(ref_nested());
55852 ref_nested().clear();
55857 template<typename V> bool encode(size_t index, V& v) const
55859 if(index != type) {return false;} return v(ref_nested());
55866 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
55868 size_t get_index() const {return type;}
55869 bool is_unknown() const { return type == 1; }
55870 void clear() {type = 0;}
55871 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
55872 template<typename V> bool decode(V& v)
55875 if(!v(ref_nested())) return false;
55876 { type = 1; return true;}
55880 template<typename V> bool encode(V& v) const
55882 return v(ref_nested());
55886 template<typename V> bool decode(size_t index, V& v)
55891 case 1: type = 1; return v(ref_nested());
55892 ref_nested().clear();
55897 template<typename V> bool encode(size_t index, V& v) const
55899 if(index != type) {return false;} return v(ref_nested());
55906 struct Extension_t : asn::typefield<true>
55908 ~Extension_t() {clear();}
55909 size_t get_index() const {return type;}
55910 bool is_unknown() const { return type == 1; }
55913 type = 0; ref_nested().clear();
55915 template<typename V> static inline void enumerate(V& v)
55920 template<typename V> bool decode(size_t index, V& v)
55925 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
55930 template<typename V> bool encode(size_t index, V& v) const
55932 if(index != type) return false;
55940 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
55942 size_t get_index() const {return type;}
55943 bool is_unknown() const { return type == 1; }
55944 void clear() {type = 0;}
55945 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
55946 template<typename V> bool decode(V& v)
55949 if(!v(ref_nested())) return false;
55950 { type = 1; return true;}
55954 template<typename V> bool encode(V& v) const
55956 return v(ref_nested());
55960 template<typename V> bool decode(size_t index, V& v)
55965 case 1: type = 1; return v(ref_nested());
55966 ref_nested().clear();
55971 template<typename V> bool encode(size_t index, V& v) const
55973 if(index != type) {return false;} return v(ref_nested());
55983 UE-ContextInformationSeNBModReq ::= SEQUENCE {
55984 uE-SecurityCapabilities UESecurityCapabilities OPTIONAL,
55985 seNB-SecurityKey SeNBSecurityKey OPTIONAL,
55986 seNBUEAggregateMaximumBitRate UEAggregateMaximumBitRate OPTIONAL,
55987 e-RABs-ToBeAdded E-RABs-ToBeAdded-List-ModReq OPTIONAL,
55988 e-RABs-ToBeModified E-RABs-ToBeModified-List-ModReq OPTIONAL,
55989 e-RABs-ToBeReleased E-RABs-ToBeReleased-List-ModReq OPTIONAL,
55990 iE-Extensions ProtocolExtensionContainer { {UE-ContextInformationSeNBModReqExtIEs} } OPTIONAL,
55995 struct UE_ContextInformationSeNBModReq : asn::sequence<7, 0, true, 7>
55997 static constexpr const char* name() {return "UE-ContextInformationSeNBModReq";}
55998 using parent_t = asn::sequence<7, 0, true, 7>;
55999 struct uE_SecurityCapabilities_t : UESecurityCapabilities
56001 static constexpr const char* name() {return "uE_SecurityCapabilities_t";}
56002 using parent_t = UESecurityCapabilities;
56003 static constexpr bool optional = true;
56006 uE_SecurityCapabilities_t& set_uE_SecurityCapabilities() { uE_SecurityCapabilities.setpresent(true); return uE_SecurityCapabilities;}
56007 uE_SecurityCapabilities_t const* get_uE_SecurityCapabilities() const {return uE_SecurityCapabilities.is_valid() ? &uE_SecurityCapabilities : nullptr;}
56008 struct seNB_SecurityKey_t : SeNBSecurityKey
56010 static constexpr const char* name() {return "seNB_SecurityKey_t";}
56011 using parent_t = SeNBSecurityKey;
56012 static constexpr bool optional = true;
56015 seNB_SecurityKey_t& set_seNB_SecurityKey() { seNB_SecurityKey.setpresent(true); return seNB_SecurityKey;}
56016 seNB_SecurityKey_t const* get_seNB_SecurityKey() const {return seNB_SecurityKey.is_valid() ? &seNB_SecurityKey : nullptr;}
56017 struct seNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
56019 static constexpr const char* name() {return "seNBUEAggregateMaximumBitRate_t";}
56020 using parent_t = UEAggregateMaximumBitRate;
56021 static constexpr bool optional = true;
56024 seNBUEAggregateMaximumBitRate_t& set_seNBUEAggregateMaximumBitRate() { seNBUEAggregateMaximumBitRate.setpresent(true); return seNBUEAggregateMaximumBitRate;}
56025 seNBUEAggregateMaximumBitRate_t const* get_seNBUEAggregateMaximumBitRate() const {return seNBUEAggregateMaximumBitRate.is_valid() ? &seNBUEAggregateMaximumBitRate : nullptr;}
56026 struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_List_ModReq
56028 static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
56029 using parent_t = E_RABs_ToBeAdded_List_ModReq;
56030 static constexpr bool optional = true;
56033 e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
56034 e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
56035 struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_List_ModReq
56037 static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
56038 using parent_t = E_RABs_ToBeModified_List_ModReq;
56039 static constexpr bool optional = true;
56042 e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
56043 e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
56044 struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_List_ModReq
56046 static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
56047 using parent_t = E_RABs_ToBeReleased_List_ModReq;
56048 static constexpr bool optional = true;
56051 e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
56052 e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
56053 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>
56055 static constexpr const char* name() {return "iE_Extensions_t";}
56056 using parent_t = ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>;
56057 static constexpr bool optional = true;
56060 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
56061 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
56062 template<typename V> void decode(V& v)
56064 v(uE_SecurityCapabilities);
56065 v(seNB_SecurityKey);
56066 v(seNBUEAggregateMaximumBitRate);
56067 v(e_RABs_ToBeAdded);
56068 v(e_RABs_ToBeModified);
56069 v(e_RABs_ToBeReleased);
56073 template<typename V> void encode(V& v) const
56075 v(uE_SecurityCapabilities);
56076 v(seNB_SecurityKey);
56077 v(seNBUEAggregateMaximumBitRate);
56078 v(e_RABs_ToBeAdded);
56079 v(e_RABs_ToBeModified);
56080 v(e_RABs_ToBeReleased);
56086 uE_SecurityCapabilities.clear();
56087 seNB_SecurityKey.clear();
56088 seNBUEAggregateMaximumBitRate.clear();
56089 e_RABs_ToBeAdded.clear();
56090 e_RABs_ToBeModified.clear();
56091 e_RABs_ToBeReleased.clear();
56092 iE_Extensions.clear();
56096 uE_SecurityCapabilities_t uE_SecurityCapabilities;
56097 seNB_SecurityKey_t seNB_SecurityKey;
56098 seNBUEAggregateMaximumBitRate_t seNBUEAggregateMaximumBitRate;
56099 e_RABs_ToBeAdded_t e_RABs_ToBeAdded;
56100 e_RABs_ToBeModified_t e_RABs_ToBeModified;
56101 e_RABs_ToBeReleased_t e_RABs_ToBeReleased;
56102 iE_Extensions_t iE_Extensions;
56106 SeNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
56107 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
56108 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
56109 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
56110 { ID id-SCGChangeIndication CRITICALITY ignore TYPE SCGChangeIndication PRESENCE optional}|
56111 { ID id-ServingPLMN CRITICALITY ignore TYPE PLMN-Identity PRESENCE optional}|
56112 { ID id-UE-ContextInformationSeNBModReq CRITICALITY reject TYPE UE-ContextInformationSeNBModReq PRESENCE optional}|
56113 { ID id-MeNBtoSeNBContainer CRITICALITY ignore TYPE MeNBtoSeNBContainer PRESENCE optional}|
56114 { ID id-CSGMembershipStatus CRITICALITY reject TYPE CSGMembershipStatus PRESENCE optional}|
56115 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
56116 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
56121 struct SeNBModificationRequest_IEs
56123 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56125 size_t get_index() const {return type;}
56126 bool is_unknown() const { return type == 11; }
56127 void clear() {type = 0;}
56128 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56129 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56130 void select_id_Cause() { set(id_Cause); type=3;}
56131 void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
56132 void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
56133 void select_id_UE_ContextInformationSeNBModReq() { set(id_UE_ContextInformationSeNBModReq); type=6;}
56134 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
56135 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
56136 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
56137 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
56138 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56139 template<typename V> bool decode(V& v)
56142 if(!v(ref_nested())) return false;
56143 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56144 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56145 else if(equal(id_Cause)) { type = 3; return true; }
56146 else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
56147 else if(equal(id_ServingPLMN)) { type = 5; return true; }
56148 else if(equal(id_UE_ContextInformationSeNBModReq)) { type = 6; return true; }
56149 else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
56150 else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
56151 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
56152 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
56153 else { type = 11; return true;}
56157 template<typename V> bool encode(V& v) const
56159 return v(ref_nested());
56163 template<typename V> bool decode(size_t index, V& v)
56168 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56169 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56170 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
56171 case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
56172 case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
56173 case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationSeNBModReq);} return false;
56174 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
56175 case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
56176 case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56177 case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56178 case 11: type = 11; return v(ref_nested());
56179 ref_nested().clear();
56184 template<typename V> bool encode(size_t index, V& v) const
56186 if(index != type) {return false;} return v(ref_nested());
56193 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56195 size_t get_index() const {return type;}
56196 bool is_unknown() const { return type == 11; }
56197 void clear() {type = 0;}
56198 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
56199 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
56200 void select_id_Cause() { set(ignore); type=3;}
56201 void select_id_SCGChangeIndication() { set(ignore); type=4;}
56202 void select_id_ServingPLMN() { set(ignore); type=5;}
56203 void select_id_UE_ContextInformationSeNBModReq() { set(reject); type=6;}
56204 void select_id_MeNBtoSeNBContainer() { set(ignore); type=7;}
56205 void select_id_CSGMembershipStatus() { set(reject); type=8;}
56206 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
56207 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
56208 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56209 template<typename V> bool decode(V& v)
56212 if(!v(ref_nested())) return false;
56213 if(equal(reject)) { type = 1; return true; }
56214 else if(equal(reject)) { type = 2; return true; }
56215 else if(equal(ignore)) { type = 3; return true; }
56216 else if(equal(ignore)) { type = 4; return true; }
56217 else if(equal(ignore)) { type = 5; return true; }
56218 else if(equal(reject)) { type = 6; return true; }
56219 else if(equal(ignore)) { type = 7; return true; }
56220 else if(equal(reject)) { type = 8; return true; }
56221 else if(equal(reject)) { type = 9; return true; }
56222 else if(equal(reject)) { type = 10; return true; }
56223 else { type = 11; return true;}
56227 template<typename V> bool encode(V& v) const
56229 return v(ref_nested());
56233 template<typename V> bool decode(size_t index, V& v)
56238 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
56239 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
56240 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56241 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56242 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56243 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
56244 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
56245 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
56246 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
56247 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
56248 case 11: type = 11; return v(ref_nested());
56249 ref_nested().clear();
56254 template<typename V> bool encode(size_t index, V& v) const
56256 if(index != type) {return false;} return v(ref_nested());
56263 struct Value_t : asn::typefield<true>
56265 ~Value_t() {clear();}
56266 size_t get_index() const {return type;}
56267 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
56268 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
56269 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
56270 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
56271 Cause& select_id_Cause() { return set<Cause>(3); }
56272 Cause const* get_id_Cause() const { return get<Cause>(3); }
56273 SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
56274 SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
56275 PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
56276 PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
56277 UE_ContextInformationSeNBModReq& select_id_UE_ContextInformationSeNBModReq() { return set<UE_ContextInformationSeNBModReq>(6); }
56278 UE_ContextInformationSeNBModReq const* get_id_UE_ContextInformationSeNBModReq() const { return get<UE_ContextInformationSeNBModReq>(6); }
56279 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
56280 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
56281 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
56282 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
56283 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
56284 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
56285 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
56286 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
56287 bool is_unknown() const { return type == 11; }
56292 case 1: var.destroy<UE_X2AP_ID>(); break;
56293 case 2: var.destroy<UE_X2AP_ID>(); break;
56294 case 3: var.destroy<Cause>(); break;
56295 case 4: var.destroy<SCGChangeIndication>(); break;
56296 case 5: var.destroy<PLMN_Identity>(); break;
56297 case 6: var.destroy<UE_ContextInformationSeNBModReq>(); break;
56298 case 7: var.destroy<MeNBtoSeNBContainer>(); break;
56299 case 8: var.destroy<CSGMembershipStatus>(); break;
56300 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
56301 case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
56303 type = 0; ref_nested().clear();
56305 template<typename V> static inline void enumerate(V& v)
56307 v.template operator()<UE_X2AP_ID>(1);
56308 v.template operator()<UE_X2AP_ID>(2);
56309 v.template operator()<Cause>(3);
56310 v.template operator()<SCGChangeIndication>(4);
56311 v.template operator()<PLMN_Identity>(5);
56312 v.template operator()<UE_ContextInformationSeNBModReq>(6);
56313 v.template operator()<MeNBtoSeNBContainer>(7);
56314 v.template operator()<CSGMembershipStatus>(8);
56315 v.template operator()<UE_X2AP_ID_Extension>(9);
56316 v.template operator()<UE_X2AP_ID_Extension>(10);
56320 template<typename V> bool decode(size_t index, V& v)
56325 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
56326 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
56327 case 3: v(select_id_Cause()); return true;
56328 case 4: v(select_id_SCGChangeIndication()); return true;
56329 case 5: v(select_id_ServingPLMN()); return true;
56330 case 6: v(select_id_UE_ContextInformationSeNBModReq()); return true;
56331 case 7: v(select_id_MeNBtoSeNBContainer()); return true;
56332 case 8: v(select_id_CSGMembershipStatus()); return true;
56333 case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
56334 case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
56335 case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
56340 template<typename V> bool encode(size_t index, V& v) const
56342 if(index != type) return false;
56345 case 1: v(var.as<UE_X2AP_ID>()); return true;
56346 case 2: v(var.as<UE_X2AP_ID>()); return true;
56347 case 3: v(var.as<Cause>()); return true;
56348 case 4: v(var.as<SCGChangeIndication>()); return true;
56349 case 5: v(var.as<PLMN_Identity>()); return true;
56350 case 6: v(var.as<UE_ContextInformationSeNBModReq>()); return true;
56351 case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
56352 case 8: v(var.as<CSGMembershipStatus>()); return true;
56353 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
56354 case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
56360 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
56361 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
56364 char dummy1[sizeof(CSGMembershipStatus)];
56365 char dummy2[sizeof(Cause)];
56366 char dummy3[sizeof(MeNBtoSeNBContainer)];
56367 char dummy4[sizeof(PLMN_Identity)];
56368 char dummy5[sizeof(SCGChangeIndication)];
56369 char dummy6[sizeof(UE_ContextInformationSeNBModReq)];
56370 char dummy7[sizeof(UE_X2AP_ID)];
56371 char dummy8[sizeof(UE_X2AP_ID_Extension)];
56374 asn::variant<sizeof(union_type)> var;
56378 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
56380 size_t get_index() const {return type;}
56381 bool is_unknown() const { return type == 11; }
56382 void clear() {type = 0;}
56383 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
56384 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
56385 void select_id_Cause() { set(mandatory); type=3;}
56386 void select_id_SCGChangeIndication() { set(optional); type=4;}
56387 void select_id_ServingPLMN() { set(optional); type=5;}
56388 void select_id_UE_ContextInformationSeNBModReq() { set(optional); type=6;}
56389 void select_id_MeNBtoSeNBContainer() { set(optional); type=7;}
56390 void select_id_CSGMembershipStatus() { set(optional); type=8;}
56391 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
56392 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
56393 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
56394 template<typename V> bool decode(V& v)
56397 if(!v(ref_nested())) return false;
56398 if(equal(mandatory)) { type = 1; return true; }
56399 else if(equal(mandatory)) { type = 2; return true; }
56400 else if(equal(mandatory)) { type = 3; return true; }
56401 else if(equal(optional)) { type = 4; return true; }
56402 else if(equal(optional)) { type = 5; return true; }
56403 else if(equal(optional)) { type = 6; return true; }
56404 else if(equal(optional)) { type = 7; return true; }
56405 else if(equal(optional)) { type = 8; return true; }
56406 else if(equal(optional)) { type = 9; return true; }
56407 else if(equal(optional)) { type = 10; return true; }
56408 else { type = 11; return true;}
56412 template<typename V> bool encode(V& v) const
56414 return v(ref_nested());
56418 template<typename V> bool decode(size_t index, V& v)
56423 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
56424 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
56425 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
56426 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
56427 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
56428 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
56429 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
56430 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
56431 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
56432 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
56433 case 11: type = 11; return v(ref_nested());
56434 ref_nested().clear();
56439 template<typename V> bool encode(size_t index, V& v) const
56441 if(index != type) {return false;} return v(ref_nested());
56451 SeNBModificationRequest ::= SEQUENCE {
56452 protocolIEs ProtocolIE-Container {{ SeNBModificationRequest-IEs}},
56457 struct SeNBModificationRequest : asn::sequence<1, 0, true, 0>
56459 static constexpr const char* name() {return "SeNBModificationRequest";}
56460 using parent_t = asn::sequence<1, 0, true, 0>;
56461 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequest_IEs>
56463 static constexpr const char* name() {return "protocolIEs_t";}
56464 using parent_t = ProtocolIE_Container<SeNBModificationRequest_IEs>;
56467 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
56468 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
56469 template<typename V> void decode(V& v)
56474 template<typename V> void encode(V& v) const
56481 protocolIEs.clear();
56485 protocolIEs_t protocolIEs;
56489 SeNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
56490 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
56491 { ID id-SeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
56492 { ID id-E-RABs-Admitted-ToBeAdded-ModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-ModAckList PRESENCE optional}|
56493 { ID id-E-RABs-Admitted-ToBeModified-ModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeModified-ModAckList PRESENCE optional}|
56494 { ID id-E-RABs-Admitted-ToBeReleased-ModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeReleased-ModAckList PRESENCE optional}|
56495 { ID id-E-RABs-NotAdmitted-List CRITICALITY ignore TYPE E-RAB-List PRESENCE optional}|
56496 { ID id-SeNBtoMeNBContainer CRITICALITY ignore TYPE SeNBtoMeNBContainer PRESENCE optional}|
56497 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
56498 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
56499 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
56504 struct SeNBModificationRequestAcknowledge_IEs
56506 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56508 size_t get_index() const {return type;}
56509 bool is_unknown() const { return type == 11; }
56510 void clear() {type = 0;}
56511 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56512 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56513 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(id_E_RABs_Admitted_ToBeAdded_ModAckList); type=3;}
56514 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(id_E_RABs_Admitted_ToBeModified_ModAckList); type=4;}
56515 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(id_E_RABs_Admitted_ToBeReleased_ModAckList); type=5;}
56516 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
56517 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=7;}
56518 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
56519 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
56520 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
56521 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56522 template<typename V> bool decode(V& v)
56525 if(!v(ref_nested())) return false;
56526 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56527 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56528 else if(equal(id_E_RABs_Admitted_ToBeAdded_ModAckList)) { type = 3; return true; }
56529 else if(equal(id_E_RABs_Admitted_ToBeModified_ModAckList)) { type = 4; return true; }
56530 else if(equal(id_E_RABs_Admitted_ToBeReleased_ModAckList)) { type = 5; return true; }
56531 else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
56532 else if(equal(id_SeNBtoMeNBContainer)) { type = 7; return true; }
56533 else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
56534 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
56535 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
56536 else { type = 11; return true;}
56540 template<typename V> bool encode(V& v) const
56542 return v(ref_nested());
56546 template<typename V> bool decode(size_t index, V& v)
56551 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56552 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56553 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_ModAckList);} return false;
56554 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_ModAckList);} return false;
56555 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_ModAckList);} return false;
56556 case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
56557 case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
56558 case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
56559 case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56560 case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56561 case 11: type = 11; return v(ref_nested());
56562 ref_nested().clear();
56567 template<typename V> bool encode(size_t index, V& v) const
56569 if(index != type) {return false;} return v(ref_nested());
56576 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56578 size_t get_index() const {return type;}
56579 bool is_unknown() const { return type == 11; }
56580 void clear() {type = 0;}
56581 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
56582 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
56583 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(ignore); type=3;}
56584 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(ignore); type=4;}
56585 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(ignore); type=5;}
56586 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
56587 void select_id_SeNBtoMeNBContainer() { set(ignore); type=7;}
56588 void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
56589 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
56590 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=10;}
56591 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56592 template<typename V> bool decode(V& v)
56595 if(!v(ref_nested())) return false;
56596 if(equal(ignore)) { type = 1; return true; }
56597 else if(equal(ignore)) { type = 2; return true; }
56598 else if(equal(ignore)) { type = 3; return true; }
56599 else if(equal(ignore)) { type = 4; return true; }
56600 else if(equal(ignore)) { type = 5; return true; }
56601 else if(equal(ignore)) { type = 6; return true; }
56602 else if(equal(ignore)) { type = 7; return true; }
56603 else if(equal(ignore)) { type = 8; return true; }
56604 else if(equal(ignore)) { type = 9; return true; }
56605 else if(equal(ignore)) { type = 10; return true; }
56606 else { type = 11; return true;}
56610 template<typename V> bool encode(V& v) const
56612 return v(ref_nested());
56616 template<typename V> bool decode(size_t index, V& v)
56621 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
56622 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
56623 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56624 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56625 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56626 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
56627 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
56628 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
56629 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
56630 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
56631 case 11: type = 11; return v(ref_nested());
56632 ref_nested().clear();
56637 template<typename V> bool encode(size_t index, V& v) const
56639 if(index != type) {return false;} return v(ref_nested());
56646 struct Value_t : asn::typefield<true>
56648 ~Value_t() {clear();}
56649 size_t get_index() const {return type;}
56650 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
56651 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
56652 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
56653 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
56654 E_RABs_Admitted_ToBeAdded_ModAckList& select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { return set<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
56655 E_RABs_Admitted_ToBeAdded_ModAckList const* get_id_E_RABs_Admitted_ToBeAdded_ModAckList() const { return get<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
56656 E_RABs_Admitted_ToBeModified_ModAckList& select_id_E_RABs_Admitted_ToBeModified_ModAckList() { return set<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
56657 E_RABs_Admitted_ToBeModified_ModAckList const* get_id_E_RABs_Admitted_ToBeModified_ModAckList() const { return get<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
56658 E_RABs_Admitted_ToBeReleased_ModAckList& select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { return set<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
56659 E_RABs_Admitted_ToBeReleased_ModAckList const* get_id_E_RABs_Admitted_ToBeReleased_ModAckList() const { return get<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
56660 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
56661 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
56662 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(7); }
56663 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(7); }
56664 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
56665 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
56666 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
56667 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
56668 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
56669 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
56670 bool is_unknown() const { return type == 11; }
56675 case 1: var.destroy<UE_X2AP_ID>(); break;
56676 case 2: var.destroy<UE_X2AP_ID>(); break;
56677 case 3: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckList>(); break;
56678 case 4: var.destroy<E_RABs_Admitted_ToBeModified_ModAckList>(); break;
56679 case 5: var.destroy<E_RABs_Admitted_ToBeReleased_ModAckList>(); break;
56680 case 6: var.destroy<E_RAB_List>(); break;
56681 case 7: var.destroy<SeNBtoMeNBContainer>(); break;
56682 case 8: var.destroy<CriticalityDiagnostics>(); break;
56683 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
56684 case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
56686 type = 0; ref_nested().clear();
56688 template<typename V> static inline void enumerate(V& v)
56690 v.template operator()<UE_X2AP_ID>(1);
56691 v.template operator()<UE_X2AP_ID>(2);
56692 v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckList>(3);
56693 v.template operator()<E_RABs_Admitted_ToBeModified_ModAckList>(4);
56694 v.template operator()<E_RABs_Admitted_ToBeReleased_ModAckList>(5);
56695 v.template operator()<E_RAB_List>(6);
56696 v.template operator()<SeNBtoMeNBContainer>(7);
56697 v.template operator()<CriticalityDiagnostics>(8);
56698 v.template operator()<UE_X2AP_ID_Extension>(9);
56699 v.template operator()<UE_X2AP_ID_Extension>(10);
56703 template<typename V> bool decode(size_t index, V& v)
56708 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
56709 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
56710 case 3: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckList()); return true;
56711 case 4: v(select_id_E_RABs_Admitted_ToBeModified_ModAckList()); return true;
56712 case 5: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckList()); return true;
56713 case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
56714 case 7: v(select_id_SeNBtoMeNBContainer()); return true;
56715 case 8: v(select_id_CriticalityDiagnostics()); return true;
56716 case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
56717 case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
56718 case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
56723 template<typename V> bool encode(size_t index, V& v) const
56725 if(index != type) return false;
56728 case 1: v(var.as<UE_X2AP_ID>()); return true;
56729 case 2: v(var.as<UE_X2AP_ID>()); return true;
56730 case 3: v(var.as<E_RABs_Admitted_ToBeAdded_ModAckList>()); return true;
56731 case 4: v(var.as<E_RABs_Admitted_ToBeModified_ModAckList>()); return true;
56732 case 5: v(var.as<E_RABs_Admitted_ToBeReleased_ModAckList>()); return true;
56733 case 6: v(var.as<E_RAB_List>()); return true;
56734 case 7: v(var.as<SeNBtoMeNBContainer>()); return true;
56735 case 8: v(var.as<CriticalityDiagnostics>()); return true;
56736 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
56737 case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
56743 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
56744 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
56747 char dummy1[sizeof(CriticalityDiagnostics)];
56748 char dummy2[sizeof(E_RAB_List)];
56749 char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_ModAckList)];
56750 char dummy4[sizeof(E_RABs_Admitted_ToBeModified_ModAckList)];
56751 char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_ModAckList)];
56752 char dummy6[sizeof(SeNBtoMeNBContainer)];
56753 char dummy7[sizeof(UE_X2AP_ID)];
56754 char dummy8[sizeof(UE_X2AP_ID_Extension)];
56757 asn::variant<sizeof(union_type)> var;
56761 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
56763 size_t get_index() const {return type;}
56764 bool is_unknown() const { return type == 11; }
56765 void clear() {type = 0;}
56766 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
56767 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
56768 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(optional); type=3;}
56769 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(optional); type=4;}
56770 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(optional); type=5;}
56771 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
56772 void select_id_SeNBtoMeNBContainer() { set(optional); type=7;}
56773 void select_id_CriticalityDiagnostics() { set(optional); type=8;}
56774 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
56775 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
56776 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
56777 template<typename V> bool decode(V& v)
56780 if(!v(ref_nested())) return false;
56781 if(equal(mandatory)) { type = 1; return true; }
56782 else if(equal(mandatory)) { type = 2; return true; }
56783 else if(equal(optional)) { type = 3; return true; }
56784 else if(equal(optional)) { type = 4; return true; }
56785 else if(equal(optional)) { type = 5; return true; }
56786 else if(equal(optional)) { type = 6; return true; }
56787 else if(equal(optional)) { type = 7; return true; }
56788 else if(equal(optional)) { type = 8; return true; }
56789 else if(equal(optional)) { type = 9; return true; }
56790 else if(equal(optional)) { type = 10; return true; }
56791 else { type = 11; return true;}
56795 template<typename V> bool encode(V& v) const
56797 return v(ref_nested());
56801 template<typename V> bool decode(size_t index, V& v)
56806 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
56807 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
56808 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
56809 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
56810 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
56811 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
56812 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
56813 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
56814 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
56815 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
56816 case 11: type = 11; return v(ref_nested());
56817 ref_nested().clear();
56822 template<typename V> bool encode(size_t index, V& v) const
56824 if(index != type) {return false;} return v(ref_nested());
56834 SeNBModificationRequestAcknowledge ::= SEQUENCE {
56835 protocolIEs ProtocolIE-Container {{SeNBModificationRequestAcknowledge-IEs}},
56840 struct SeNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
56842 static constexpr const char* name() {return "SeNBModificationRequestAcknowledge";}
56843 using parent_t = asn::sequence<1, 0, true, 0>;
56844 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>
56846 static constexpr const char* name() {return "protocolIEs_t";}
56847 using parent_t = ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>;
56850 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
56851 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
56852 template<typename V> void decode(V& v)
56857 template<typename V> void encode(V& v) const
56864 protocolIEs.clear();
56868 protocolIEs_t protocolIEs;
56872 SeNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
56873 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
56874 { ID id-SeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
56875 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
56876 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
56877 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
56878 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
56883 struct SeNBModificationRequestReject_IEs
56885 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56887 size_t get_index() const {return type;}
56888 bool is_unknown() const { return type == 7; }
56889 void clear() {type = 0;}
56890 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56891 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56892 void select_id_Cause() { set(id_Cause); type=3;}
56893 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
56894 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
56895 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
56896 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56897 template<typename V> bool decode(V& v)
56900 if(!v(ref_nested())) return false;
56901 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56902 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56903 else if(equal(id_Cause)) { type = 3; return true; }
56904 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
56905 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
56906 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
56907 else { type = 7; return true;}
56911 template<typename V> bool encode(V& v) const
56913 return v(ref_nested());
56917 template<typename V> bool decode(size_t index, V& v)
56922 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56923 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56924 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
56925 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
56926 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56927 case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56928 case 7: type = 7; return v(ref_nested());
56929 ref_nested().clear();
56934 template<typename V> bool encode(size_t index, V& v) const
56936 if(index != type) {return false;} return v(ref_nested());
56943 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56945 size_t get_index() const {return type;}
56946 bool is_unknown() const { return type == 7; }
56947 void clear() {type = 0;}
56948 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
56949 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
56950 void select_id_Cause() { set(ignore); type=3;}
56951 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
56952 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
56953 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
56954 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56955 template<typename V> bool decode(V& v)
56958 if(!v(ref_nested())) return false;
56959 if(equal(ignore)) { type = 1; return true; }
56960 else if(equal(ignore)) { type = 2; return true; }
56961 else if(equal(ignore)) { type = 3; return true; }
56962 else if(equal(ignore)) { type = 4; return true; }
56963 else if(equal(ignore)) { type = 5; return true; }
56964 else if(equal(ignore)) { type = 6; return true; }
56965 else { type = 7; return true;}
56969 template<typename V> bool encode(V& v) const
56971 return v(ref_nested());
56975 template<typename V> bool decode(size_t index, V& v)
56980 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
56981 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
56982 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56983 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56984 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56985 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
56986 case 7: type = 7; return v(ref_nested());
56987 ref_nested().clear();
56992 template<typename V> bool encode(size_t index, V& v) const
56994 if(index != type) {return false;} return v(ref_nested());
57001 struct Value_t : asn::typefield<true>
57003 ~Value_t() {clear();}
57004 size_t get_index() const {return type;}
57005 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57006 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57007 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57008 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57009 Cause& select_id_Cause() { return set<Cause>(3); }
57010 Cause const* get_id_Cause() const { return get<Cause>(3); }
57011 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
57012 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
57013 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57014 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57015 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
57016 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
57017 bool is_unknown() const { return type == 7; }
57022 case 1: var.destroy<UE_X2AP_ID>(); break;
57023 case 2: var.destroy<UE_X2AP_ID>(); break;
57024 case 3: var.destroy<Cause>(); break;
57025 case 4: var.destroy<CriticalityDiagnostics>(); break;
57026 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57027 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
57029 type = 0; ref_nested().clear();
57031 template<typename V> static inline void enumerate(V& v)
57033 v.template operator()<UE_X2AP_ID>(1);
57034 v.template operator()<UE_X2AP_ID>(2);
57035 v.template operator()<Cause>(3);
57036 v.template operator()<CriticalityDiagnostics>(4);
57037 v.template operator()<UE_X2AP_ID_Extension>(5);
57038 v.template operator()<UE_X2AP_ID_Extension>(6);
57042 template<typename V> bool decode(size_t index, V& v)
57047 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57048 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57049 case 3: v(select_id_Cause()); return true;
57050 case 4: v(select_id_CriticalityDiagnostics()); return true;
57051 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57052 case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57053 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
57058 template<typename V> bool encode(size_t index, V& v) const
57060 if(index != type) return false;
57063 case 1: v(var.as<UE_X2AP_ID>()); return true;
57064 case 2: v(var.as<UE_X2AP_ID>()); return true;
57065 case 3: v(var.as<Cause>()); return true;
57066 case 4: v(var.as<CriticalityDiagnostics>()); return true;
57067 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
57068 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
57074 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57075 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57078 char dummy1[sizeof(Cause)];
57079 char dummy2[sizeof(CriticalityDiagnostics)];
57080 char dummy3[sizeof(UE_X2AP_ID)];
57081 char dummy4[sizeof(UE_X2AP_ID_Extension)];
57084 asn::variant<sizeof(union_type)> var;
57088 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57090 size_t get_index() const {return type;}
57091 bool is_unknown() const { return type == 7; }
57092 void clear() {type = 0;}
57093 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57094 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57095 void select_id_Cause() { set(mandatory); type=3;}
57096 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
57097 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
57098 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
57099 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57100 template<typename V> bool decode(V& v)
57103 if(!v(ref_nested())) return false;
57104 if(equal(mandatory)) { type = 1; return true; }
57105 else if(equal(mandatory)) { type = 2; return true; }
57106 else if(equal(mandatory)) { type = 3; return true; }
57107 else if(equal(optional)) { type = 4; return true; }
57108 else if(equal(optional)) { type = 5; return true; }
57109 else if(equal(optional)) { type = 6; return true; }
57110 else { type = 7; return true;}
57114 template<typename V> bool encode(V& v) const
57116 return v(ref_nested());
57120 template<typename V> bool decode(size_t index, V& v)
57125 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57126 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57127 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57128 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57129 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57130 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
57131 case 7: type = 7; return v(ref_nested());
57132 ref_nested().clear();
57137 template<typename V> bool encode(size_t index, V& v) const
57139 if(index != type) {return false;} return v(ref_nested());
57149 SeNBModificationRequestReject ::= SEQUENCE {
57150 protocolIEs ProtocolIE-Container {{SeNBModificationRequestReject-IEs}},
57155 struct SeNBModificationRequestReject : asn::sequence<1, 0, true, 0>
57157 static constexpr const char* name() {return "SeNBModificationRequestReject";}
57158 using parent_t = asn::sequence<1, 0, true, 0>;
57159 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestReject_IEs>
57161 static constexpr const char* name() {return "protocolIEs_t";}
57162 using parent_t = ProtocolIE_Container<SeNBModificationRequestReject_IEs>;
57165 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57166 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57167 template<typename V> void decode(V& v)
57172 template<typename V> void encode(V& v) const
57179 protocolIEs.clear();
57183 protocolIEs_t protocolIEs;
57187 SeNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
57188 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
57189 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
57190 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
57191 { ID id-SCGChangeIndication CRITICALITY ignore TYPE SCGChangeIndication PRESENCE optional}|
57192 { ID id-E-RABs-ToBeReleased-ModReqd CRITICALITY ignore TYPE E-RABs-ToBeReleased-ModReqd PRESENCE optional}|
57193 { ID id-SeNBtoMeNBContainer CRITICALITY ignore TYPE SeNBtoMeNBContainer PRESENCE optional}|
57194 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
57195 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
57200 struct SeNBModificationRequired_IEs
57202 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57204 size_t get_index() const {return type;}
57205 bool is_unknown() const { return type == 9; }
57206 void clear() {type = 0;}
57207 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57208 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57209 void select_id_Cause() { set(id_Cause); type=3;}
57210 void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
57211 void select_id_E_RABs_ToBeReleased_ModReqd() { set(id_E_RABs_ToBeReleased_ModReqd); type=5;}
57212 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=6;}
57213 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
57214 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
57215 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57216 template<typename V> bool decode(V& v)
57219 if(!v(ref_nested())) return false;
57220 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57221 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57222 else if(equal(id_Cause)) { type = 3; return true; }
57223 else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
57224 else if(equal(id_E_RABs_ToBeReleased_ModReqd)) { type = 5; return true; }
57225 else if(equal(id_SeNBtoMeNBContainer)) { type = 6; return true; }
57226 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
57227 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
57228 else { type = 9; return true;}
57232 template<typename V> bool encode(V& v) const
57234 return v(ref_nested());
57238 template<typename V> bool decode(size_t index, V& v)
57243 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57244 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57245 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
57246 case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
57247 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqd);} return false;
57248 case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
57249 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57250 case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57251 case 9: type = 9; return v(ref_nested());
57252 ref_nested().clear();
57257 template<typename V> bool encode(size_t index, V& v) const
57259 if(index != type) {return false;} return v(ref_nested());
57266 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57268 size_t get_index() const {return type;}
57269 bool is_unknown() const { return type == 9; }
57270 void clear() {type = 0;}
57271 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
57272 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
57273 void select_id_Cause() { set(ignore); type=3;}
57274 void select_id_SCGChangeIndication() { set(ignore); type=4;}
57275 void select_id_E_RABs_ToBeReleased_ModReqd() { set(ignore); type=5;}
57276 void select_id_SeNBtoMeNBContainer() { set(ignore); type=6;}
57277 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
57278 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=8;}
57279 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57280 template<typename V> bool decode(V& v)
57283 if(!v(ref_nested())) return false;
57284 if(equal(reject)) { type = 1; return true; }
57285 else if(equal(reject)) { type = 2; return true; }
57286 else if(equal(ignore)) { type = 3; return true; }
57287 else if(equal(ignore)) { type = 4; return true; }
57288 else if(equal(ignore)) { type = 5; return true; }
57289 else if(equal(ignore)) { type = 6; return true; }
57290 else if(equal(reject)) { type = 7; return true; }
57291 else if(equal(reject)) { type = 8; return true; }
57292 else { type = 9; return true;}
57296 template<typename V> bool encode(V& v) const
57298 return v(ref_nested());
57302 template<typename V> bool decode(size_t index, V& v)
57307 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
57308 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
57309 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57310 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
57311 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
57312 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
57313 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
57314 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
57315 case 9: type = 9; return v(ref_nested());
57316 ref_nested().clear();
57321 template<typename V> bool encode(size_t index, V& v) const
57323 if(index != type) {return false;} return v(ref_nested());
57330 struct Value_t : asn::typefield<true>
57332 ~Value_t() {clear();}
57333 size_t get_index() const {return type;}
57334 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57335 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57336 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57337 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57338 Cause& select_id_Cause() { return set<Cause>(3); }
57339 Cause const* get_id_Cause() const { return get<Cause>(3); }
57340 SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
57341 SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
57342 E_RABs_ToBeReleased_ModReqd& select_id_E_RABs_ToBeReleased_ModReqd() { return set<E_RABs_ToBeReleased_ModReqd>(5); }
57343 E_RABs_ToBeReleased_ModReqd const* get_id_E_RABs_ToBeReleased_ModReqd() const { return get<E_RABs_ToBeReleased_ModReqd>(5); }
57344 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(6); }
57345 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(6); }
57346 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
57347 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
57348 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
57349 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
57350 bool is_unknown() const { return type == 9; }
57355 case 1: var.destroy<UE_X2AP_ID>(); break;
57356 case 2: var.destroy<UE_X2AP_ID>(); break;
57357 case 3: var.destroy<Cause>(); break;
57358 case 4: var.destroy<SCGChangeIndication>(); break;
57359 case 5: var.destroy<E_RABs_ToBeReleased_ModReqd>(); break;
57360 case 6: var.destroy<SeNBtoMeNBContainer>(); break;
57361 case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
57362 case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
57364 type = 0; ref_nested().clear();
57366 template<typename V> static inline void enumerate(V& v)
57368 v.template operator()<UE_X2AP_ID>(1);
57369 v.template operator()<UE_X2AP_ID>(2);
57370 v.template operator()<Cause>(3);
57371 v.template operator()<SCGChangeIndication>(4);
57372 v.template operator()<E_RABs_ToBeReleased_ModReqd>(5);
57373 v.template operator()<SeNBtoMeNBContainer>(6);
57374 v.template operator()<UE_X2AP_ID_Extension>(7);
57375 v.template operator()<UE_X2AP_ID_Extension>(8);
57379 template<typename V> bool decode(size_t index, V& v)
57384 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57385 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57386 case 3: v(select_id_Cause()); return true;
57387 case 4: v(select_id_SCGChangeIndication()); return true;
57388 case 5: v(select_id_E_RABs_ToBeReleased_ModReqd()); return true;
57389 case 6: v(select_id_SeNBtoMeNBContainer()); return true;
57390 case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57391 case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57392 case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
57397 template<typename V> bool encode(size_t index, V& v) const
57399 if(index != type) return false;
57402 case 1: v(var.as<UE_X2AP_ID>()); return true;
57403 case 2: v(var.as<UE_X2AP_ID>()); return true;
57404 case 3: v(var.as<Cause>()); return true;
57405 case 4: v(var.as<SCGChangeIndication>()); return true;
57406 case 5: v(var.as<E_RABs_ToBeReleased_ModReqd>()); return true;
57407 case 6: v(var.as<SeNBtoMeNBContainer>()); return true;
57408 case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
57409 case 8: v(var.as<UE_X2AP_ID_Extension>()); return true;
57415 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57416 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57419 char dummy1[sizeof(Cause)];
57420 char dummy2[sizeof(E_RABs_ToBeReleased_ModReqd)];
57421 char dummy3[sizeof(SCGChangeIndication)];
57422 char dummy4[sizeof(SeNBtoMeNBContainer)];
57423 char dummy5[sizeof(UE_X2AP_ID)];
57424 char dummy6[sizeof(UE_X2AP_ID_Extension)];
57427 asn::variant<sizeof(union_type)> var;
57431 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57433 size_t get_index() const {return type;}
57434 bool is_unknown() const { return type == 9; }
57435 void clear() {type = 0;}
57436 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57437 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57438 void select_id_Cause() { set(mandatory); type=3;}
57439 void select_id_SCGChangeIndication() { set(optional); type=4;}
57440 void select_id_E_RABs_ToBeReleased_ModReqd() { set(optional); type=5;}
57441 void select_id_SeNBtoMeNBContainer() { set(optional); type=6;}
57442 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
57443 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
57444 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57445 template<typename V> bool decode(V& v)
57448 if(!v(ref_nested())) return false;
57449 if(equal(mandatory)) { type = 1; return true; }
57450 else if(equal(mandatory)) { type = 2; return true; }
57451 else if(equal(mandatory)) { type = 3; return true; }
57452 else if(equal(optional)) { type = 4; return true; }
57453 else if(equal(optional)) { type = 5; return true; }
57454 else if(equal(optional)) { type = 6; return true; }
57455 else if(equal(optional)) { type = 7; return true; }
57456 else if(equal(optional)) { type = 8; return true; }
57457 else { type = 9; return true;}
57461 template<typename V> bool encode(V& v) const
57463 return v(ref_nested());
57467 template<typename V> bool decode(size_t index, V& v)
57472 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57473 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57474 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57475 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57476 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57477 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
57478 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
57479 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
57480 case 9: type = 9; return v(ref_nested());
57481 ref_nested().clear();
57486 template<typename V> bool encode(size_t index, V& v) const
57488 if(index != type) {return false;} return v(ref_nested());
57498 SeNBModificationRequired ::= SEQUENCE {
57499 protocolIEs ProtocolIE-Container {{SeNBModificationRequired-IEs}},
57504 struct SeNBModificationRequired : asn::sequence<1, 0, true, 0>
57506 static constexpr const char* name() {return "SeNBModificationRequired";}
57507 using parent_t = asn::sequence<1, 0, true, 0>;
57508 struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequired_IEs>
57510 static constexpr const char* name() {return "protocolIEs_t";}
57511 using parent_t = ProtocolIE_Container<SeNBModificationRequired_IEs>;
57514 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57515 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57516 template<typename V> void decode(V& v)
57521 template<typename V> void encode(V& v) const
57528 protocolIEs.clear();
57532 protocolIEs_t protocolIEs;
57536 SeNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
57537 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
57538 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
57539 { ID id-ResponseInformationSeNBReconfComp CRITICALITY ignore TYPE ResponseInformationSeNBReconfComp PRESENCE mandatory}|
57540 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
57541 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
57546 struct SeNBReconfigurationComplete_IEs
57548 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57550 size_t get_index() const {return type;}
57551 bool is_unknown() const { return type == 6; }
57552 void clear() {type = 0;}
57553 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57554 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57555 void select_id_ResponseInformationSeNBReconfComp() { set(id_ResponseInformationSeNBReconfComp); type=3;}
57556 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
57557 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
57558 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57559 template<typename V> bool decode(V& v)
57562 if(!v(ref_nested())) return false;
57563 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57564 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57565 else if(equal(id_ResponseInformationSeNBReconfComp)) { type = 3; return true; }
57566 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
57567 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
57568 else { type = 6; return true;}
57572 template<typename V> bool encode(V& v) const
57574 return v(ref_nested());
57578 template<typename V> bool decode(size_t index, V& v)
57583 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57584 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57585 case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSeNBReconfComp);} return false;
57586 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57587 case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57588 case 6: type = 6; return v(ref_nested());
57589 ref_nested().clear();
57594 template<typename V> bool encode(size_t index, V& v) const
57596 if(index != type) {return false;} return v(ref_nested());
57603 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57605 size_t get_index() const {return type;}
57606 bool is_unknown() const { return type == 6; }
57607 void clear() {type = 0;}
57608 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
57609 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
57610 void select_id_ResponseInformationSeNBReconfComp() { set(ignore); type=3;}
57611 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
57612 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
57613 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57614 template<typename V> bool decode(V& v)
57617 if(!v(ref_nested())) return false;
57618 if(equal(reject)) { type = 1; return true; }
57619 else if(equal(reject)) { type = 2; return true; }
57620 else if(equal(ignore)) { type = 3; return true; }
57621 else if(equal(reject)) { type = 4; return true; }
57622 else if(equal(reject)) { type = 5; return true; }
57623 else { type = 6; return true;}
57627 template<typename V> bool encode(V& v) const
57629 return v(ref_nested());
57633 template<typename V> bool decode(size_t index, V& v)
57638 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
57639 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
57640 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57641 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
57642 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
57643 case 6: type = 6; return v(ref_nested());
57644 ref_nested().clear();
57649 template<typename V> bool encode(size_t index, V& v) const
57651 if(index != type) {return false;} return v(ref_nested());
57658 struct Value_t : asn::typefield<true>
57660 ~Value_t() {clear();}
57661 size_t get_index() const {return type;}
57662 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57663 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57664 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57665 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57666 ResponseInformationSeNBReconfComp& select_id_ResponseInformationSeNBReconfComp() { return set<ResponseInformationSeNBReconfComp>(3); }
57667 ResponseInformationSeNBReconfComp const* get_id_ResponseInformationSeNBReconfComp() const { return get<ResponseInformationSeNBReconfComp>(3); }
57668 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
57669 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
57670 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57671 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57672 bool is_unknown() const { return type == 6; }
57677 case 1: var.destroy<UE_X2AP_ID>(); break;
57678 case 2: var.destroy<UE_X2AP_ID>(); break;
57679 case 3: var.destroy<ResponseInformationSeNBReconfComp>(); break;
57680 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
57681 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57683 type = 0; ref_nested().clear();
57685 template<typename V> static inline void enumerate(V& v)
57687 v.template operator()<UE_X2AP_ID>(1);
57688 v.template operator()<UE_X2AP_ID>(2);
57689 v.template operator()<ResponseInformationSeNBReconfComp>(3);
57690 v.template operator()<UE_X2AP_ID_Extension>(4);
57691 v.template operator()<UE_X2AP_ID_Extension>(5);
57695 template<typename V> bool decode(size_t index, V& v)
57700 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57701 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57702 case 3: v(select_id_ResponseInformationSeNBReconfComp()); return true;
57703 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57704 case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57705 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
57710 template<typename V> bool encode(size_t index, V& v) const
57712 if(index != type) return false;
57715 case 1: v(var.as<UE_X2AP_ID>()); return true;
57716 case 2: v(var.as<UE_X2AP_ID>()); return true;
57717 case 3: v(var.as<ResponseInformationSeNBReconfComp>()); return true;
57718 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
57719 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
57725 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57726 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57729 char dummy1[sizeof(ResponseInformationSeNBReconfComp)];
57730 char dummy2[sizeof(UE_X2AP_ID)];
57731 char dummy3[sizeof(UE_X2AP_ID_Extension)];
57734 asn::variant<sizeof(union_type)> var;
57738 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57740 size_t get_index() const {return type;}
57741 bool is_unknown() const { return type == 6; }
57742 void clear() {type = 0;}
57743 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57744 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57745 void select_id_ResponseInformationSeNBReconfComp() { set(mandatory); type=3;}
57746 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
57747 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
57748 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57749 template<typename V> bool decode(V& v)
57752 if(!v(ref_nested())) return false;
57753 if(equal(mandatory)) { type = 1; return true; }
57754 else if(equal(mandatory)) { type = 2; return true; }
57755 else if(equal(mandatory)) { type = 3; return true; }
57756 else if(equal(optional)) { type = 4; return true; }
57757 else if(equal(optional)) { type = 5; return true; }
57758 else { type = 6; return true;}
57762 template<typename V> bool encode(V& v) const
57764 return v(ref_nested());
57768 template<typename V> bool decode(size_t index, V& v)
57773 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57774 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57775 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57776 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57777 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57778 case 6: type = 6; return v(ref_nested());
57779 ref_nested().clear();
57784 template<typename V> bool encode(size_t index, V& v) const
57786 if(index != type) {return false;} return v(ref_nested());
57796 SeNBReconfigurationComplete ::= SEQUENCE {
57797 protocolIEs ProtocolIE-Container {{SeNBReconfigurationComplete-IEs}},
57802 struct SeNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
57804 static constexpr const char* name() {return "SeNBReconfigurationComplete";}
57805 using parent_t = asn::sequence<1, 0, true, 0>;
57806 struct protocolIEs_t : ProtocolIE_Container<SeNBReconfigurationComplete_IEs>
57808 static constexpr const char* name() {return "protocolIEs_t";}
57809 using parent_t = ProtocolIE_Container<SeNBReconfigurationComplete_IEs>;
57812 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57813 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57814 template<typename V> void decode(V& v)
57819 template<typename V> void encode(V& v) const
57826 protocolIEs.clear();
57830 protocolIEs_t protocolIEs;
57834 SeNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
57835 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
57836 { ID id-SeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
57837 { ID id-E-RABs-ToBeReleased-List-RelConf CRITICALITY ignore TYPE E-RABs-ToBeReleased-List-RelConf PRESENCE optional}|
57838 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
57839 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
57840 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
57845 struct SeNBReleaseConfirm_IEs
57847 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57849 size_t get_index() const {return type;}
57850 bool is_unknown() const { return type == 7; }
57851 void clear() {type = 0;}
57852 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57853 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57854 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(id_E_RABs_ToBeReleased_List_RelConf); type=3;}
57855 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
57856 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
57857 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
57858 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57859 template<typename V> bool decode(V& v)
57862 if(!v(ref_nested())) return false;
57863 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57864 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57865 else if(equal(id_E_RABs_ToBeReleased_List_RelConf)) { type = 3; return true; }
57866 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
57867 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
57868 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
57869 else { type = 7; return true;}
57873 template<typename V> bool encode(V& v) const
57875 return v(ref_nested());
57879 template<typename V> bool decode(size_t index, V& v)
57884 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57885 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57886 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelConf);} return false;
57887 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
57888 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57889 case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57890 case 7: type = 7; return v(ref_nested());
57891 ref_nested().clear();
57896 template<typename V> bool encode(size_t index, V& v) const
57898 if(index != type) {return false;} return v(ref_nested());
57905 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57907 size_t get_index() const {return type;}
57908 bool is_unknown() const { return type == 7; }
57909 void clear() {type = 0;}
57910 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
57911 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
57912 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(ignore); type=3;}
57913 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
57914 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
57915 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
57916 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57917 template<typename V> bool decode(V& v)
57920 if(!v(ref_nested())) return false;
57921 if(equal(ignore)) { type = 1; return true; }
57922 else if(equal(ignore)) { type = 2; return true; }
57923 else if(equal(ignore)) { type = 3; return true; }
57924 else if(equal(ignore)) { type = 4; return true; }
57925 else if(equal(ignore)) { type = 5; return true; }
57926 else if(equal(ignore)) { type = 6; return true; }
57927 else { type = 7; return true;}
57931 template<typename V> bool encode(V& v) const
57933 return v(ref_nested());
57937 template<typename V> bool decode(size_t index, V& v)
57942 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
57943 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
57944 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57945 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
57946 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
57947 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
57948 case 7: type = 7; return v(ref_nested());
57949 ref_nested().clear();
57954 template<typename V> bool encode(size_t index, V& v) const
57956 if(index != type) {return false;} return v(ref_nested());
57963 struct Value_t : asn::typefield<true>
57965 ~Value_t() {clear();}
57966 size_t get_index() const {return type;}
57967 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57968 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57969 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57970 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57971 E_RABs_ToBeReleased_List_RelConf& select_id_E_RABs_ToBeReleased_List_RelConf() { return set<E_RABs_ToBeReleased_List_RelConf>(3); }
57972 E_RABs_ToBeReleased_List_RelConf const* get_id_E_RABs_ToBeReleased_List_RelConf() const { return get<E_RABs_ToBeReleased_List_RelConf>(3); }
57973 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
57974 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
57975 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57976 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57977 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
57978 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
57979 bool is_unknown() const { return type == 7; }
57984 case 1: var.destroy<UE_X2AP_ID>(); break;
57985 case 2: var.destroy<UE_X2AP_ID>(); break;
57986 case 3: var.destroy<E_RABs_ToBeReleased_List_RelConf>(); break;
57987 case 4: var.destroy<CriticalityDiagnostics>(); break;
57988 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57989 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
57991 type = 0; ref_nested().clear();
57993 template<typename V> static inline void enumerate(V& v)
57995 v.template operator()<UE_X2AP_ID>(1);
57996 v.template operator()<UE_X2AP_ID>(2);
57997 v.template operator()<E_RABs_ToBeReleased_List_RelConf>(3);
57998 v.template operator()<CriticalityDiagnostics>(4);
57999 v.template operator()<UE_X2AP_ID_Extension>(5);
58000 v.template operator()<UE_X2AP_ID_Extension>(6);
58004 template<typename V> bool decode(size_t index, V& v)
58009 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58010 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58011 case 3: v(select_id_E_RABs_ToBeReleased_List_RelConf()); return true;
58012 case 4: v(select_id_CriticalityDiagnostics()); return true;
58013 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58014 case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58015 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
58020 template<typename V> bool encode(size_t index, V& v) const
58022 if(index != type) return false;
58025 case 1: v(var.as<UE_X2AP_ID>()); return true;
58026 case 2: v(var.as<UE_X2AP_ID>()); return true;
58027 case 3: v(var.as<E_RABs_ToBeReleased_List_RelConf>()); return true;
58028 case 4: v(var.as<CriticalityDiagnostics>()); return true;
58029 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
58030 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
58036 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58037 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58040 char dummy1[sizeof(CriticalityDiagnostics)];
58041 char dummy2[sizeof(E_RABs_ToBeReleased_List_RelConf)];
58042 char dummy3[sizeof(UE_X2AP_ID)];
58043 char dummy4[sizeof(UE_X2AP_ID_Extension)];
58046 asn::variant<sizeof(union_type)> var;
58050 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58052 size_t get_index() const {return type;}
58053 bool is_unknown() const { return type == 7; }
58054 void clear() {type = 0;}
58055 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58056 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
58057 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(optional); type=3;}
58058 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
58059 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
58060 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
58061 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58062 template<typename V> bool decode(V& v)
58065 if(!v(ref_nested())) return false;
58066 if(equal(mandatory)) { type = 1; return true; }
58067 else if(equal(mandatory)) { type = 2; return true; }
58068 else if(equal(optional)) { type = 3; return true; }
58069 else if(equal(optional)) { type = 4; return true; }
58070 else if(equal(optional)) { type = 5; return true; }
58071 else if(equal(optional)) { type = 6; return true; }
58072 else { type = 7; return true;}
58076 template<typename V> bool encode(V& v) const
58078 return v(ref_nested());
58082 template<typename V> bool decode(size_t index, V& v)
58087 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58088 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
58089 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
58090 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58091 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58092 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
58093 case 7: type = 7; return v(ref_nested());
58094 ref_nested().clear();
58099 template<typename V> bool encode(size_t index, V& v) const
58101 if(index != type) {return false;} return v(ref_nested());
58111 SeNBReleaseConfirm ::= SEQUENCE {
58112 protocolIEs ProtocolIE-Container {{SeNBReleaseConfirm-IEs}},
58117 struct SeNBReleaseConfirm : asn::sequence<1, 0, true, 0>
58119 static constexpr const char* name() {return "SeNBReleaseConfirm";}
58120 using parent_t = asn::sequence<1, 0, true, 0>;
58121 struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseConfirm_IEs>
58123 static constexpr const char* name() {return "protocolIEs_t";}
58124 using parent_t = ProtocolIE_Container<SeNBReleaseConfirm_IEs>;
58127 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58128 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58129 template<typename V> void decode(V& v)
58134 template<typename V> void encode(V& v) const
58141 protocolIEs.clear();
58145 protocolIEs_t protocolIEs;
58149 SeNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
58150 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
58151 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE optional}|
58152 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE optional}|
58153 { ID id-E-RABs-ToBeReleased-List-RelReq CRITICALITY ignore TYPE E-RABs-ToBeReleased-List-RelReq PRESENCE optional}|
58154 { ID id-UE-ContextKeptIndicator CRITICALITY ignore TYPE UE-ContextKeptIndicator PRESENCE optional}|
58155 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
58156 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
58157 { ID id-MakeBeforeBreakIndicator CRITICALITY ignore TYPE MakeBeforeBreakIndicator PRESENCE optional},
58162 struct SeNBReleaseRequest_IEs
58164 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58166 size_t get_index() const {return type;}
58167 bool is_unknown() const { return type == 9; }
58168 void clear() {type = 0;}
58169 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58170 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
58171 void select_id_Cause() { set(id_Cause); type=3;}
58172 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(id_E_RABs_ToBeReleased_List_RelReq); type=4;}
58173 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
58174 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
58175 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
58176 void select_id_MakeBeforeBreakIndicator() { set(id_MakeBeforeBreakIndicator); type=8;}
58177 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58178 template<typename V> bool decode(V& v)
58181 if(!v(ref_nested())) return false;
58182 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58183 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
58184 else if(equal(id_Cause)) { type = 3; return true; }
58185 else if(equal(id_E_RABs_ToBeReleased_List_RelReq)) { type = 4; return true; }
58186 else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
58187 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
58188 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
58189 else if(equal(id_MakeBeforeBreakIndicator)) { type = 8; return true; }
58190 else { type = 9; return true;}
58194 template<typename V> bool encode(V& v) const
58196 return v(ref_nested());
58200 template<typename V> bool decode(size_t index, V& v)
58205 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58206 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
58207 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
58208 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelReq);} return false;
58209 case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
58210 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58211 case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
58212 case 8: type = 8; if(v(ref_nested())) { return equal(id_MakeBeforeBreakIndicator);} return false;
58213 case 9: type = 9; return v(ref_nested());
58214 ref_nested().clear();
58219 template<typename V> bool encode(size_t index, V& v) const
58221 if(index != type) {return false;} return v(ref_nested());
58228 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58230 size_t get_index() const {return type;}
58231 bool is_unknown() const { return type == 9; }
58232 void clear() {type = 0;}
58233 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58234 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
58235 void select_id_Cause() { set(ignore); type=3;}
58236 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(ignore); type=4;}
58237 void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
58238 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
58239 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
58240 void select_id_MakeBeforeBreakIndicator() { set(ignore); type=8;}
58241 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58242 template<typename V> bool decode(V& v)
58245 if(!v(ref_nested())) return false;
58246 if(equal(reject)) { type = 1; return true; }
58247 else if(equal(reject)) { type = 2; return true; }
58248 else if(equal(ignore)) { type = 3; return true; }
58249 else if(equal(ignore)) { type = 4; return true; }
58250 else if(equal(ignore)) { type = 5; return true; }
58251 else if(equal(reject)) { type = 6; return true; }
58252 else if(equal(reject)) { type = 7; return true; }
58253 else if(equal(ignore)) { type = 8; return true; }
58254 else { type = 9; return true;}
58258 template<typename V> bool encode(V& v) const
58260 return v(ref_nested());
58264 template<typename V> bool decode(size_t index, V& v)
58269 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58270 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58271 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
58272 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
58273 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
58274 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
58275 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
58276 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
58277 case 9: type = 9; return v(ref_nested());
58278 ref_nested().clear();
58283 template<typename V> bool encode(size_t index, V& v) const
58285 if(index != type) {return false;} return v(ref_nested());
58292 struct Value_t : asn::typefield<true>
58294 ~Value_t() {clear();}
58295 size_t get_index() const {return type;}
58296 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58297 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58298 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
58299 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
58300 Cause& select_id_Cause() { return set<Cause>(3); }
58301 Cause const* get_id_Cause() const { return get<Cause>(3); }
58302 E_RABs_ToBeReleased_List_RelReq& select_id_E_RABs_ToBeReleased_List_RelReq() { return set<E_RABs_ToBeReleased_List_RelReq>(4); }
58303 E_RABs_ToBeReleased_List_RelReq const* get_id_E_RABs_ToBeReleased_List_RelReq() const { return get<E_RABs_ToBeReleased_List_RelReq>(4); }
58304 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
58305 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
58306 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
58307 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
58308 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
58309 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
58310 MakeBeforeBreakIndicator& select_id_MakeBeforeBreakIndicator() { return set<MakeBeforeBreakIndicator>(8); }
58311 MakeBeforeBreakIndicator const* get_id_MakeBeforeBreakIndicator() const { return get<MakeBeforeBreakIndicator>(8); }
58312 bool is_unknown() const { return type == 9; }
58317 case 1: var.destroy<UE_X2AP_ID>(); break;
58318 case 2: var.destroy<UE_X2AP_ID>(); break;
58319 case 3: var.destroy<Cause>(); break;
58320 case 4: var.destroy<E_RABs_ToBeReleased_List_RelReq>(); break;
58321 case 5: var.destroy<UE_ContextKeptIndicator>(); break;
58322 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
58323 case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
58324 case 8: var.destroy<MakeBeforeBreakIndicator>(); break;
58326 type = 0; ref_nested().clear();
58328 template<typename V> static inline void enumerate(V& v)
58330 v.template operator()<UE_X2AP_ID>(1);
58331 v.template operator()<UE_X2AP_ID>(2);
58332 v.template operator()<Cause>(3);
58333 v.template operator()<E_RABs_ToBeReleased_List_RelReq>(4);
58334 v.template operator()<UE_ContextKeptIndicator>(5);
58335 v.template operator()<UE_X2AP_ID_Extension>(6);
58336 v.template operator()<UE_X2AP_ID_Extension>(7);
58337 v.template operator()<MakeBeforeBreakIndicator>(8);
58341 template<typename V> bool decode(size_t index, V& v)
58346 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58347 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58348 case 3: v(select_id_Cause()); return true;
58349 case 4: v(select_id_E_RABs_ToBeReleased_List_RelReq()); return true;
58350 case 5: v(select_id_UE_ContextKeptIndicator()); return true;
58351 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58352 case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58353 case 8: v(select_id_MakeBeforeBreakIndicator()); return true;
58354 case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
58359 template<typename V> bool encode(size_t index, V& v) const
58361 if(index != type) return false;
58364 case 1: v(var.as<UE_X2AP_ID>()); return true;
58365 case 2: v(var.as<UE_X2AP_ID>()); return true;
58366 case 3: v(var.as<Cause>()); return true;
58367 case 4: v(var.as<E_RABs_ToBeReleased_List_RelReq>()); return true;
58368 case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
58369 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
58370 case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
58371 case 8: v(var.as<MakeBeforeBreakIndicator>()); return true;
58377 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58378 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58381 char dummy1[sizeof(Cause)];
58382 char dummy2[sizeof(E_RABs_ToBeReleased_List_RelReq)];
58383 char dummy3[sizeof(MakeBeforeBreakIndicator)];
58384 char dummy4[sizeof(UE_ContextKeptIndicator)];
58385 char dummy5[sizeof(UE_X2AP_ID)];
58386 char dummy6[sizeof(UE_X2AP_ID_Extension)];
58389 asn::variant<sizeof(union_type)> var;
58393 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58395 size_t get_index() const {return type;}
58396 bool is_unknown() const { return type == 9; }
58397 void clear() {type = 0;}
58398 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58399 void select_id_SeNB_UE_X2AP_ID() { set(optional); type=2;}
58400 void select_id_Cause() { set(optional); type=3;}
58401 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(optional); type=4;}
58402 void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
58403 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
58404 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
58405 void select_id_MakeBeforeBreakIndicator() { set(optional); type=8;}
58406 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58407 template<typename V> bool decode(V& v)
58410 if(!v(ref_nested())) return false;
58411 if(equal(mandatory)) { type = 1; return true; }
58412 else if(equal(optional)) { type = 2; return true; }
58413 else if(equal(optional)) { type = 3; return true; }
58414 else if(equal(optional)) { type = 4; return true; }
58415 else if(equal(optional)) { type = 5; return true; }
58416 else if(equal(optional)) { type = 6; return true; }
58417 else if(equal(optional)) { type = 7; return true; }
58418 else if(equal(optional)) { type = 8; return true; }
58419 else { type = 9; return true;}
58423 template<typename V> bool encode(V& v) const
58425 return v(ref_nested());
58429 template<typename V> bool decode(size_t index, V& v)
58434 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58435 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
58436 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
58437 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58438 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58439 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
58440 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
58441 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
58442 case 9: type = 9; return v(ref_nested());
58443 ref_nested().clear();
58448 template<typename V> bool encode(size_t index, V& v) const
58450 if(index != type) {return false;} return v(ref_nested());
58460 SeNBReleaseRequest ::= SEQUENCE {
58461 protocolIEs ProtocolIE-Container {{SeNBReleaseRequest-IEs}},
58466 struct SeNBReleaseRequest : asn::sequence<1, 0, true, 0>
58468 static constexpr const char* name() {return "SeNBReleaseRequest";}
58469 using parent_t = asn::sequence<1, 0, true, 0>;
58470 struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequest_IEs>
58472 static constexpr const char* name() {return "protocolIEs_t";}
58473 using parent_t = ProtocolIE_Container<SeNBReleaseRequest_IEs>;
58476 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58477 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58478 template<typename V> void decode(V& v)
58483 template<typename V> void encode(V& v) const
58490 protocolIEs.clear();
58494 protocolIEs_t protocolIEs;
58498 SeNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
58499 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
58500 { ID id-SeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
58501 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
58502 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
58503 { ID id-SeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
58508 struct SeNBReleaseRequired_IEs
58510 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58512 size_t get_index() const {return type;}
58513 bool is_unknown() const { return type == 6; }
58514 void clear() {type = 0;}
58515 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58516 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
58517 void select_id_Cause() { set(id_Cause); type=3;}
58518 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
58519 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
58520 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58521 template<typename V> bool decode(V& v)
58524 if(!v(ref_nested())) return false;
58525 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58526 else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
58527 else if(equal(id_Cause)) { type = 3; return true; }
58528 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
58529 else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
58530 else { type = 6; return true;}
58534 template<typename V> bool encode(V& v) const
58536 return v(ref_nested());
58540 template<typename V> bool decode(size_t index, V& v)
58545 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58546 case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
58547 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
58548 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58549 case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
58550 case 6: type = 6; return v(ref_nested());
58551 ref_nested().clear();
58556 template<typename V> bool encode(size_t index, V& v) const
58558 if(index != type) {return false;} return v(ref_nested());
58565 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58567 size_t get_index() const {return type;}
58568 bool is_unknown() const { return type == 6; }
58569 void clear() {type = 0;}
58570 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58571 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
58572 void select_id_Cause() { set(ignore); type=3;}
58573 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
58574 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
58575 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58576 template<typename V> bool decode(V& v)
58579 if(!v(ref_nested())) return false;
58580 if(equal(reject)) { type = 1; return true; }
58581 else if(equal(reject)) { type = 2; return true; }
58582 else if(equal(ignore)) { type = 3; return true; }
58583 else if(equal(reject)) { type = 4; return true; }
58584 else if(equal(reject)) { type = 5; return true; }
58585 else { type = 6; return true;}
58589 template<typename V> bool encode(V& v) const
58591 return v(ref_nested());
58595 template<typename V> bool decode(size_t index, V& v)
58600 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58601 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58602 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
58603 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
58604 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
58605 case 6: type = 6; return v(ref_nested());
58606 ref_nested().clear();
58611 template<typename V> bool encode(size_t index, V& v) const
58613 if(index != type) {return false;} return v(ref_nested());
58620 struct Value_t : asn::typefield<true>
58622 ~Value_t() {clear();}
58623 size_t get_index() const {return type;}
58624 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58625 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58626 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
58627 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
58628 Cause& select_id_Cause() { return set<Cause>(3); }
58629 Cause const* get_id_Cause() const { return get<Cause>(3); }
58630 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
58631 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
58632 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
58633 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
58634 bool is_unknown() const { return type == 6; }
58639 case 1: var.destroy<UE_X2AP_ID>(); break;
58640 case 2: var.destroy<UE_X2AP_ID>(); break;
58641 case 3: var.destroy<Cause>(); break;
58642 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
58643 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
58645 type = 0; ref_nested().clear();
58647 template<typename V> static inline void enumerate(V& v)
58649 v.template operator()<UE_X2AP_ID>(1);
58650 v.template operator()<UE_X2AP_ID>(2);
58651 v.template operator()<Cause>(3);
58652 v.template operator()<UE_X2AP_ID_Extension>(4);
58653 v.template operator()<UE_X2AP_ID_Extension>(5);
58657 template<typename V> bool decode(size_t index, V& v)
58662 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58663 case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58664 case 3: v(select_id_Cause()); return true;
58665 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58666 case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58667 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
58672 template<typename V> bool encode(size_t index, V& v) const
58674 if(index != type) return false;
58677 case 1: v(var.as<UE_X2AP_ID>()); return true;
58678 case 2: v(var.as<UE_X2AP_ID>()); return true;
58679 case 3: v(var.as<Cause>()); return true;
58680 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
58681 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
58687 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58688 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58691 char dummy1[sizeof(Cause)];
58692 char dummy2[sizeof(UE_X2AP_ID)];
58693 char dummy3[sizeof(UE_X2AP_ID_Extension)];
58696 asn::variant<sizeof(union_type)> var;
58700 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58702 size_t get_index() const {return type;}
58703 bool is_unknown() const { return type == 6; }
58704 void clear() {type = 0;}
58705 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58706 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
58707 void select_id_Cause() { set(mandatory); type=3;}
58708 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
58709 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
58710 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58711 template<typename V> bool decode(V& v)
58714 if(!v(ref_nested())) return false;
58715 if(equal(mandatory)) { type = 1; return true; }
58716 else if(equal(mandatory)) { type = 2; return true; }
58717 else if(equal(mandatory)) { type = 3; return true; }
58718 else if(equal(optional)) { type = 4; return true; }
58719 else if(equal(optional)) { type = 5; return true; }
58720 else { type = 6; return true;}
58724 template<typename V> bool encode(V& v) const
58726 return v(ref_nested());
58730 template<typename V> bool decode(size_t index, V& v)
58735 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58736 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
58737 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
58738 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58739 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58740 case 6: type = 6; return v(ref_nested());
58741 ref_nested().clear();
58746 template<typename V> bool encode(size_t index, V& v) const
58748 if(index != type) {return false;} return v(ref_nested());
58758 SeNBReleaseRequired ::= SEQUENCE {
58759 protocolIEs ProtocolIE-Container {{SeNBReleaseRequired-IEs}},
58764 struct SeNBReleaseRequired : asn::sequence<1, 0, true, 0>
58766 static constexpr const char* name() {return "SeNBReleaseRequired";}
58767 using parent_t = asn::sequence<1, 0, true, 0>;
58768 struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequired_IEs>
58770 static constexpr const char* name() {return "protocolIEs_t";}
58771 using parent_t = ProtocolIE_Container<SeNBReleaseRequired_IEs>;
58774 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58775 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58776 template<typename V> void decode(V& v)
58781 template<typename V> void encode(V& v) const
58788 protocolIEs.clear();
58792 protocolIEs_t protocolIEs;
58796 SecondaryRATDataUsageReport-IEs X2AP-PROTOCOL-IES ::= {
58797 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
58798 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
58799 { ID id-SecondaryRATUsageReportList CRITICALITY reject TYPE SecondaryRATUsageReportList PRESENCE mandatory}|
58800 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
58805 struct SecondaryRATDataUsageReport_IEs
58807 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58809 size_t get_index() const {return type;}
58810 bool is_unknown() const { return type == 5; }
58811 void clear() {type = 0;}
58812 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58813 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
58814 void select_id_SecondaryRATUsageReportList() { set(id_SecondaryRATUsageReportList); type=3;}
58815 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
58816 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58817 template<typename V> bool decode(V& v)
58820 if(!v(ref_nested())) return false;
58821 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58822 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
58823 else if(equal(id_SecondaryRATUsageReportList)) { type = 3; return true; }
58824 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
58825 else { type = 5; return true;}
58829 template<typename V> bool encode(V& v) const
58831 return v(ref_nested());
58835 template<typename V> bool decode(size_t index, V& v)
58840 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58841 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
58842 case 3: type = 3; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReportList);} return false;
58843 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58844 case 5: type = 5; return v(ref_nested());
58845 ref_nested().clear();
58850 template<typename V> bool encode(size_t index, V& v) const
58852 if(index != type) {return false;} return v(ref_nested());
58859 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58861 size_t get_index() const {return type;}
58862 bool is_unknown() const { return type == 5; }
58863 void clear() {type = 0;}
58864 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58865 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
58866 void select_id_SecondaryRATUsageReportList() { set(reject); type=3;}
58867 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
58868 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58869 template<typename V> bool decode(V& v)
58872 if(!v(ref_nested())) return false;
58873 if(equal(reject)) { type = 1; return true; }
58874 else if(equal(reject)) { type = 2; return true; }
58875 else if(equal(reject)) { type = 3; return true; }
58876 else if(equal(reject)) { type = 4; return true; }
58877 else { type = 5; return true;}
58881 template<typename V> bool encode(V& v) const
58883 return v(ref_nested());
58887 template<typename V> bool decode(size_t index, V& v)
58892 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58893 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58894 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
58895 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
58896 case 5: type = 5; return v(ref_nested());
58897 ref_nested().clear();
58902 template<typename V> bool encode(size_t index, V& v) const
58904 if(index != type) {return false;} return v(ref_nested());
58911 struct Value_t : asn::typefield<true>
58913 ~Value_t() {clear();}
58914 size_t get_index() const {return type;}
58915 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58916 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58917 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
58918 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
58919 SecondaryRATUsageReportList& select_id_SecondaryRATUsageReportList() { return set<SecondaryRATUsageReportList>(3); }
58920 SecondaryRATUsageReportList const* get_id_SecondaryRATUsageReportList() const { return get<SecondaryRATUsageReportList>(3); }
58921 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
58922 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
58923 bool is_unknown() const { return type == 5; }
58928 case 1: var.destroy<UE_X2AP_ID>(); break;
58929 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
58930 case 3: var.destroy<SecondaryRATUsageReportList>(); break;
58931 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
58933 type = 0; ref_nested().clear();
58935 template<typename V> static inline void enumerate(V& v)
58937 v.template operator()<UE_X2AP_ID>(1);
58938 v.template operator()<SgNB_UE_X2AP_ID>(2);
58939 v.template operator()<SecondaryRATUsageReportList>(3);
58940 v.template operator()<UE_X2AP_ID_Extension>(4);
58944 template<typename V> bool decode(size_t index, V& v)
58949 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58950 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
58951 case 3: v(select_id_SecondaryRATUsageReportList()); return true;
58952 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58953 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
58958 template<typename V> bool encode(size_t index, V& v) const
58960 if(index != type) return false;
58963 case 1: v(var.as<UE_X2AP_ID>()); return true;
58964 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
58965 case 3: v(var.as<SecondaryRATUsageReportList>()); return true;
58966 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
58972 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58973 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58976 char dummy1[sizeof(SecondaryRATUsageReportList)];
58977 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
58978 char dummy3[sizeof(UE_X2AP_ID)];
58979 char dummy4[sizeof(UE_X2AP_ID_Extension)];
58982 asn::variant<sizeof(union_type)> var;
58986 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58988 size_t get_index() const {return type;}
58989 bool is_unknown() const { return type == 5; }
58990 void clear() {type = 0;}
58991 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58992 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
58993 void select_id_SecondaryRATUsageReportList() { set(mandatory); type=3;}
58994 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
58995 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58996 template<typename V> bool decode(V& v)
58999 if(!v(ref_nested())) return false;
59000 if(equal(mandatory)) { type = 1; return true; }
59001 else if(equal(mandatory)) { type = 2; return true; }
59002 else if(equal(mandatory)) { type = 3; return true; }
59003 else if(equal(optional)) { type = 4; return true; }
59004 else { type = 5; return true;}
59008 template<typename V> bool encode(V& v) const
59010 return v(ref_nested());
59014 template<typename V> bool decode(size_t index, V& v)
59019 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59020 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59021 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
59022 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
59023 case 5: type = 5; return v(ref_nested());
59024 ref_nested().clear();
59029 template<typename V> bool encode(size_t index, V& v) const
59031 if(index != type) {return false;} return v(ref_nested());
59041 SecondaryRATDataUsageReport ::= SEQUENCE {
59042 protocolIEs ProtocolIE-Container {{SecondaryRATDataUsageReport-IEs}},
59047 struct SecondaryRATDataUsageReport : asn::sequence<1, 0, true, 0>
59049 static constexpr const char* name() {return "SecondaryRATDataUsageReport";}
59050 using parent_t = asn::sequence<1, 0, true, 0>;
59051 struct protocolIEs_t : ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>
59053 static constexpr const char* name() {return "protocolIEs_t";}
59054 using parent_t = ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>;
59057 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59058 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59059 template<typename V> void decode(V& v)
59064 template<typename V> void encode(V& v) const
59071 protocolIEs.clear();
59075 protocolIEs_t protocolIEs;
59079 SgNBActivityNotification-IEs X2AP-PROTOCOL-IES ::= {
59080 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
59081 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
59082 { ID id-UEContextLevelUserPlaneActivity CRITICALITY ignore TYPE UserPlaneTrafficActivityReport PRESENCE optional}|
59083 { ID id-ERABActivityNotifyItemList CRITICALITY ignore TYPE ERABActivityNotifyItemList PRESENCE optional}|
59084 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
59089 struct SgNBActivityNotification_IEs
59091 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59093 size_t get_index() const {return type;}
59094 bool is_unknown() const { return type == 6; }
59095 void clear() {type = 0;}
59096 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59097 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
59098 void select_id_UEContextLevelUserPlaneActivity() { set(id_UEContextLevelUserPlaneActivity); type=3;}
59099 void select_id_ERABActivityNotifyItemList() { set(id_ERABActivityNotifyItemList); type=4;}
59100 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
59101 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59102 template<typename V> bool decode(V& v)
59105 if(!v(ref_nested())) return false;
59106 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59107 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
59108 else if(equal(id_UEContextLevelUserPlaneActivity)) { type = 3; return true; }
59109 else if(equal(id_ERABActivityNotifyItemList)) { type = 4; return true; }
59110 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
59111 else { type = 6; return true;}
59115 template<typename V> bool encode(V& v) const
59117 return v(ref_nested());
59121 template<typename V> bool decode(size_t index, V& v)
59126 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59127 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59128 case 3: type = 3; if(v(ref_nested())) { return equal(id_UEContextLevelUserPlaneActivity);} return false;
59129 case 4: type = 4; if(v(ref_nested())) { return equal(id_ERABActivityNotifyItemList);} return false;
59130 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59131 case 6: type = 6; return v(ref_nested());
59132 ref_nested().clear();
59137 template<typename V> bool encode(size_t index, V& v) const
59139 if(index != type) {return false;} return v(ref_nested());
59146 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59148 size_t get_index() const {return type;}
59149 bool is_unknown() const { return type == 6; }
59150 void clear() {type = 0;}
59151 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59152 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
59153 void select_id_UEContextLevelUserPlaneActivity() { set(ignore); type=3;}
59154 void select_id_ERABActivityNotifyItemList() { set(ignore); type=4;}
59155 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
59156 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59157 template<typename V> bool decode(V& v)
59160 if(!v(ref_nested())) return false;
59161 if(equal(reject)) { type = 1; return true; }
59162 else if(equal(reject)) { type = 2; return true; }
59163 else if(equal(ignore)) { type = 3; return true; }
59164 else if(equal(ignore)) { type = 4; return true; }
59165 else if(equal(reject)) { type = 5; return true; }
59166 else { type = 6; return true;}
59170 template<typename V> bool encode(V& v) const
59172 return v(ref_nested());
59176 template<typename V> bool decode(size_t index, V& v)
59181 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59182 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
59183 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
59184 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
59185 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
59186 case 6: type = 6; return v(ref_nested());
59187 ref_nested().clear();
59192 template<typename V> bool encode(size_t index, V& v) const
59194 if(index != type) {return false;} return v(ref_nested());
59201 struct Value_t : asn::typefield<true>
59203 ~Value_t() {clear();}
59204 size_t get_index() const {return type;}
59205 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
59206 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
59207 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
59208 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
59209 UserPlaneTrafficActivityReport& select_id_UEContextLevelUserPlaneActivity() { return set<UserPlaneTrafficActivityReport>(3); }
59210 UserPlaneTrafficActivityReport const* get_id_UEContextLevelUserPlaneActivity() const { return get<UserPlaneTrafficActivityReport>(3); }
59211 ERABActivityNotifyItemList& select_id_ERABActivityNotifyItemList() { return set<ERABActivityNotifyItemList>(4); }
59212 ERABActivityNotifyItemList const* get_id_ERABActivityNotifyItemList() const { return get<ERABActivityNotifyItemList>(4); }
59213 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
59214 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
59215 bool is_unknown() const { return type == 6; }
59220 case 1: var.destroy<UE_X2AP_ID>(); break;
59221 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
59222 case 3: var.destroy<UserPlaneTrafficActivityReport>(); break;
59223 case 4: var.destroy<ERABActivityNotifyItemList>(); break;
59224 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
59226 type = 0; ref_nested().clear();
59228 template<typename V> static inline void enumerate(V& v)
59230 v.template operator()<UE_X2AP_ID>(1);
59231 v.template operator()<SgNB_UE_X2AP_ID>(2);
59232 v.template operator()<UserPlaneTrafficActivityReport>(3);
59233 v.template operator()<ERABActivityNotifyItemList>(4);
59234 v.template operator()<UE_X2AP_ID_Extension>(5);
59238 template<typename V> bool decode(size_t index, V& v)
59243 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
59244 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
59245 case 3: v(select_id_UEContextLevelUserPlaneActivity()); return true;
59246 case 4: v(select_id_ERABActivityNotifyItemList()); return true;
59247 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
59248 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
59253 template<typename V> bool encode(size_t index, V& v) const
59255 if(index != type) return false;
59258 case 1: v(var.as<UE_X2AP_ID>()); return true;
59259 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
59260 case 3: v(var.as<UserPlaneTrafficActivityReport>()); return true;
59261 case 4: v(var.as<ERABActivityNotifyItemList>()); return true;
59262 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
59268 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
59269 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
59272 char dummy1[sizeof(ERABActivityNotifyItemList)];
59273 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
59274 char dummy3[sizeof(UE_X2AP_ID)];
59275 char dummy4[sizeof(UE_X2AP_ID_Extension)];
59276 char dummy5[sizeof(UserPlaneTrafficActivityReport)];
59279 asn::variant<sizeof(union_type)> var;
59283 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
59285 size_t get_index() const {return type;}
59286 bool is_unknown() const { return type == 6; }
59287 void clear() {type = 0;}
59288 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
59289 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
59290 void select_id_UEContextLevelUserPlaneActivity() { set(optional); type=3;}
59291 void select_id_ERABActivityNotifyItemList() { set(optional); type=4;}
59292 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
59293 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
59294 template<typename V> bool decode(V& v)
59297 if(!v(ref_nested())) return false;
59298 if(equal(mandatory)) { type = 1; return true; }
59299 else if(equal(mandatory)) { type = 2; return true; }
59300 else if(equal(optional)) { type = 3; return true; }
59301 else if(equal(optional)) { type = 4; return true; }
59302 else if(equal(optional)) { type = 5; return true; }
59303 else { type = 6; return true;}
59307 template<typename V> bool encode(V& v) const
59309 return v(ref_nested());
59313 template<typename V> bool decode(size_t index, V& v)
59318 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59319 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59320 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
59321 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
59322 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
59323 case 6: type = 6; return v(ref_nested());
59324 ref_nested().clear();
59329 template<typename V> bool encode(size_t index, V& v) const
59331 if(index != type) {return false;} return v(ref_nested());
59341 SgNBActivityNotification ::= SEQUENCE {
59342 protocolIEs ProtocolIE-Container {{SgNBActivityNotification-IEs}},
59347 struct SgNBActivityNotification : asn::sequence<1, 0, true, 0>
59349 static constexpr const char* name() {return "SgNBActivityNotification";}
59350 using parent_t = asn::sequence<1, 0, true, 0>;
59351 struct protocolIEs_t : ProtocolIE_Container<SgNBActivityNotification_IEs>
59353 static constexpr const char* name() {return "protocolIEs_t";}
59354 using parent_t = ProtocolIE_Container<SgNBActivityNotification_IEs>;
59357 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59358 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59359 template<typename V> void decode(V& v)
59364 template<typename V> void encode(V& v) const
59371 protocolIEs.clear();
59375 protocolIEs_t protocolIEs;
59379 SgNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
59380 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
59381 { ID id-NRUESecurityCapabilities CRITICALITY reject TYPE NRUESecurityCapabilities PRESENCE mandatory}|
59382 { ID id-SgNBSecurityKey CRITICALITY reject TYPE SgNBSecurityKey PRESENCE mandatory}|
59383 { ID id-SgNBUEAggregateMaximumBitRate CRITICALITY reject TYPE UEAggregateMaximumBitRate PRESENCE mandatory}|
59384 { ID id-SelectedPLMN CRITICALITY ignore TYPE PLMN-Identity PRESENCE optional}|
59385 { ID id-HandoverRestrictionList CRITICALITY ignore TYPE HandoverRestrictionList PRESENCE optional}|
59386 { ID id-E-RABs-ToBeAdded-SgNBAddReqList CRITICALITY reject TYPE E-RABs-ToBeAdded-SgNBAddReqList PRESENCE mandatory}|
59387 { ID id-MeNBtoSgNBContainer CRITICALITY reject TYPE MeNBtoSgNBContainer PRESENCE mandatory}|
59388 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE optional}|
59389 { ID id-ExpectedUEBehaviour CRITICALITY ignore TYPE ExpectedUEBehaviour PRESENCE optional}|
59390 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
59391 { ID id-RequestedSplitSRBs CRITICALITY reject TYPE SplitSRBs PRESENCE optional}|
59392 { ID id-MeNBResourceCoordinationInformation CRITICALITY ignore TYPE MeNBResourceCoordinationInformation PRESENCE optional}|
59393 { ID id-SGNB-Addition-Trigger-Ind CRITICALITY reject TYPE SGNB-Addition-Trigger-Ind PRESENCE optional}|
59394 { ID id-SubscriberProfileIDforRFP CRITICALITY ignore TYPE SubscriberProfileIDforRFP PRESENCE optional}|
59395 { ID id-MeNBCell-ID CRITICALITY reject TYPE ECGI PRESENCE mandatory},
59400 struct SgNBAdditionRequest_IEs
59402 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59404 size_t get_index() const {return type;}
59405 bool is_unknown() const { return type == 17; }
59406 void clear() {type = 0;}
59407 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59408 void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=2;}
59409 void select_id_SgNBSecurityKey() { set(id_SgNBSecurityKey); type=3;}
59410 void select_id_SgNBUEAggregateMaximumBitRate() { set(id_SgNBUEAggregateMaximumBitRate); type=4;}
59411 void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=5;}
59412 void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=6;}
59413 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(id_E_RABs_ToBeAdded_SgNBAddReqList); type=7;}
59414 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
59415 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=9;}
59416 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
59417 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=11;}
59418 void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=12;}
59419 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=13;}
59420 void select_id_SGNB_Addition_Trigger_Ind() { set(id_SGNB_Addition_Trigger_Ind); type=14;}
59421 void select_id_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); type=15;}
59422 void select_id_MeNBCell_ID() { set(id_MeNBCell_ID); type=16;}
59423 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59424 template<typename V> bool decode(V& v)
59427 if(!v(ref_nested())) return false;
59428 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59429 else if(equal(id_NRUESecurityCapabilities)) { type = 2; return true; }
59430 else if(equal(id_SgNBSecurityKey)) { type = 3; return true; }
59431 else if(equal(id_SgNBUEAggregateMaximumBitRate)) { type = 4; return true; }
59432 else if(equal(id_SelectedPLMN)) { type = 5; return true; }
59433 else if(equal(id_HandoverRestrictionList)) { type = 6; return true; }
59434 else if(equal(id_E_RABs_ToBeAdded_SgNBAddReqList)) { type = 7; return true; }
59435 else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
59436 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 9; return true; }
59437 else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
59438 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 11; return true; }
59439 else if(equal(id_RequestedSplitSRBs)) { type = 12; return true; }
59440 else if(equal(id_MeNBResourceCoordinationInformation)) { type = 13; return true; }
59441 else if(equal(id_SGNB_Addition_Trigger_Ind)) { type = 14; return true; }
59442 else if(equal(id_SubscriberProfileIDforRFP)) { type = 15; return true; }
59443 else if(equal(id_MeNBCell_ID)) { type = 16; return true; }
59444 else { type = 17; return true;}
59448 template<typename V> bool encode(V& v) const
59450 return v(ref_nested());
59454 template<typename V> bool decode(size_t index, V& v)
59459 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59460 case 2: type = 2; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
59461 case 3: type = 3; if(v(ref_nested())) { return equal(id_SgNBSecurityKey);} return false;
59462 case 4: type = 4; if(v(ref_nested())) { return equal(id_SgNBUEAggregateMaximumBitRate);} return false;
59463 case 5: type = 5; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
59464 case 6: type = 6; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
59465 case 7: type = 7; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBAddReqList);} return false;
59466 case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
59467 case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59468 case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
59469 case 11: type = 11; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59470 case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
59471 case 13: type = 13; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
59472 case 14: type = 14; if(v(ref_nested())) { return equal(id_SGNB_Addition_Trigger_Ind);} return false;
59473 case 15: type = 15; if(v(ref_nested())) { return equal(id_SubscriberProfileIDforRFP);} return false;
59474 case 16: type = 16; if(v(ref_nested())) { return equal(id_MeNBCell_ID);} return false;
59475 case 17: type = 17; return v(ref_nested());
59476 ref_nested().clear();
59481 template<typename V> bool encode(size_t index, V& v) const
59483 if(index != type) {return false;} return v(ref_nested());
59490 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59492 size_t get_index() const {return type;}
59493 bool is_unknown() const { return type == 17; }
59494 void clear() {type = 0;}
59495 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59496 void select_id_NRUESecurityCapabilities() { set(reject); type=2;}
59497 void select_id_SgNBSecurityKey() { set(reject); type=3;}
59498 void select_id_SgNBUEAggregateMaximumBitRate() { set(reject); type=4;}
59499 void select_id_SelectedPLMN() { set(ignore); type=5;}
59500 void select_id_HandoverRestrictionList() { set(ignore); type=6;}
59501 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(reject); type=7;}
59502 void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
59503 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=9;}
59504 void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
59505 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=11;}
59506 void select_id_RequestedSplitSRBs() { set(reject); type=12;}
59507 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=13;}
59508 void select_id_SGNB_Addition_Trigger_Ind() { set(reject); type=14;}
59509 void select_id_SubscriberProfileIDforRFP() { set(ignore); type=15;}
59510 void select_id_MeNBCell_ID() { set(reject); type=16;}
59511 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59512 template<typename V> bool decode(V& v)
59515 if(!v(ref_nested())) return false;
59516 if(equal(reject)) { type = 1; return true; }
59517 else if(equal(reject)) { type = 2; return true; }
59518 else if(equal(reject)) { type = 3; return true; }
59519 else if(equal(reject)) { type = 4; return true; }
59520 else if(equal(ignore)) { type = 5; return true; }
59521 else if(equal(ignore)) { type = 6; return true; }
59522 else if(equal(reject)) { type = 7; return true; }
59523 else if(equal(reject)) { type = 8; return true; }
59524 else if(equal(reject)) { type = 9; return true; }
59525 else if(equal(ignore)) { type = 10; return true; }
59526 else if(equal(reject)) { type = 11; return true; }
59527 else if(equal(reject)) { type = 12; return true; }
59528 else if(equal(ignore)) { type = 13; return true; }
59529 else if(equal(reject)) { type = 14; return true; }
59530 else if(equal(ignore)) { type = 15; return true; }
59531 else if(equal(reject)) { type = 16; return true; }
59532 else { type = 17; return true;}
59536 template<typename V> bool encode(V& v) const
59538 return v(ref_nested());
59542 template<typename V> bool decode(size_t index, V& v)
59547 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59548 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
59549 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
59550 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
59551 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
59552 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
59553 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
59554 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
59555 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
59556 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
59557 case 11: type = 11; if(v(ref_nested())) { return equal(reject);} return false;
59558 case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
59559 case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
59560 case 14: type = 14; if(v(ref_nested())) { return equal(reject);} return false;
59561 case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
59562 case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
59563 case 17: type = 17; return v(ref_nested());
59564 ref_nested().clear();
59569 template<typename V> bool encode(size_t index, V& v) const
59571 if(index != type) {return false;} return v(ref_nested());
59578 struct Value_t : asn::typefield<true>
59580 ~Value_t() {clear();}
59581 size_t get_index() const {return type;}
59582 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
59583 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
59584 NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(2); }
59585 NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(2); }
59586 SgNBSecurityKey& select_id_SgNBSecurityKey() { return set<SgNBSecurityKey>(3); }
59587 SgNBSecurityKey const* get_id_SgNBSecurityKey() const { return get<SgNBSecurityKey>(3); }
59588 UEAggregateMaximumBitRate& select_id_SgNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
59589 UEAggregateMaximumBitRate const* get_id_SgNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
59590 PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(5); }
59591 PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(5); }
59592 HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(6); }
59593 HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(6); }
59594 E_RABs_ToBeAdded_SgNBAddReqList& select_id_E_RABs_ToBeAdded_SgNBAddReqList() { return set<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
59595 E_RABs_ToBeAdded_SgNBAddReqList const* get_id_E_RABs_ToBeAdded_SgNBAddReqList() const { return get<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
59596 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
59597 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
59598 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(9); }
59599 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(9); }
59600 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
59601 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
59602 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(11); }
59603 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(11); }
59604 SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(12); }
59605 SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(12); }
59606 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(13); }
59607 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(13); }
59608 SGNB_Addition_Trigger_Ind& select_id_SGNB_Addition_Trigger_Ind() { return set<SGNB_Addition_Trigger_Ind>(14); }
59609 SGNB_Addition_Trigger_Ind const* get_id_SGNB_Addition_Trigger_Ind() const { return get<SGNB_Addition_Trigger_Ind>(14); }
59610 SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(15); }
59611 SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(15); }
59612 ECGI& select_id_MeNBCell_ID() { return set<ECGI>(16); }
59613 ECGI const* get_id_MeNBCell_ID() const { return get<ECGI>(16); }
59614 bool is_unknown() const { return type == 17; }
59619 case 1: var.destroy<UE_X2AP_ID>(); break;
59620 case 2: var.destroy<NRUESecurityCapabilities>(); break;
59621 case 3: var.destroy<SgNBSecurityKey>(); break;
59622 case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
59623 case 5: var.destroy<PLMN_Identity>(); break;
59624 case 6: var.destroy<HandoverRestrictionList>(); break;
59625 case 7: var.destroy<E_RABs_ToBeAdded_SgNBAddReqList>(); break;
59626 case 8: var.destroy<MeNBtoSgNBContainer>(); break;
59627 case 9: var.destroy<SgNB_UE_X2AP_ID>(); break;
59628 case 10: var.destroy<ExpectedUEBehaviour>(); break;
59629 case 11: var.destroy<UE_X2AP_ID_Extension>(); break;
59630 case 12: var.destroy<SplitSRBs>(); break;
59631 case 13: var.destroy<MeNBResourceCoordinationInformation>(); break;
59632 case 14: var.destroy<SGNB_Addition_Trigger_Ind>(); break;
59633 case 15: var.destroy<SubscriberProfileIDforRFP>(); break;
59634 case 16: var.destroy<ECGI>(); break;
59636 type = 0; ref_nested().clear();
59638 template<typename V> static inline void enumerate(V& v)
59640 v.template operator()<UE_X2AP_ID>(1);
59641 v.template operator()<NRUESecurityCapabilities>(2);
59642 v.template operator()<SgNBSecurityKey>(3);
59643 v.template operator()<UEAggregateMaximumBitRate>(4);
59644 v.template operator()<PLMN_Identity>(5);
59645 v.template operator()<HandoverRestrictionList>(6);
59646 v.template operator()<E_RABs_ToBeAdded_SgNBAddReqList>(7);
59647 v.template operator()<MeNBtoSgNBContainer>(8);
59648 v.template operator()<SgNB_UE_X2AP_ID>(9);
59649 v.template operator()<ExpectedUEBehaviour>(10);
59650 v.template operator()<UE_X2AP_ID_Extension>(11);
59651 v.template operator()<SplitSRBs>(12);
59652 v.template operator()<MeNBResourceCoordinationInformation>(13);
59653 v.template operator()<SGNB_Addition_Trigger_Ind>(14);
59654 v.template operator()<SubscriberProfileIDforRFP>(15);
59655 v.template operator()<ECGI>(16);
59659 template<typename V> bool decode(size_t index, V& v)
59664 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
59665 case 2: v(select_id_NRUESecurityCapabilities()); return true;
59666 case 3: v(select_id_SgNBSecurityKey()); return true;
59667 case 4: v(select_id_SgNBUEAggregateMaximumBitRate()); return true;
59668 case 5: v(select_id_SelectedPLMN()); return true;
59669 case 6: v(select_id_HandoverRestrictionList()); return true;
59670 case 7: v(select_id_E_RABs_ToBeAdded_SgNBAddReqList()); return true;
59671 case 8: v(select_id_MeNBtoSgNBContainer()); return true;
59672 case 9: v(select_id_SgNB_UE_X2AP_ID()); return true;
59673 case 10: v(select_id_ExpectedUEBehaviour()); return true;
59674 case 11: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
59675 case 12: v(select_id_RequestedSplitSRBs()); return true;
59676 case 13: v(select_id_MeNBResourceCoordinationInformation()); return true;
59677 case 14: v(select_id_SGNB_Addition_Trigger_Ind()); return true;
59678 case 15: v(select_id_SubscriberProfileIDforRFP()); return true;
59679 case 16: v(select_id_MeNBCell_ID()); return true;
59680 case 17: if(type != 17) {clear(); asn::base::set();} type = 17; return true;
59685 template<typename V> bool encode(size_t index, V& v) const
59687 if(index != type) return false;
59690 case 1: v(var.as<UE_X2AP_ID>()); return true;
59691 case 2: v(var.as<NRUESecurityCapabilities>()); return true;
59692 case 3: v(var.as<SgNBSecurityKey>()); return true;
59693 case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
59694 case 5: v(var.as<PLMN_Identity>()); return true;
59695 case 6: v(var.as<HandoverRestrictionList>()); return true;
59696 case 7: v(var.as<E_RABs_ToBeAdded_SgNBAddReqList>()); return true;
59697 case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
59698 case 9: v(var.as<SgNB_UE_X2AP_ID>()); return true;
59699 case 10: v(var.as<ExpectedUEBehaviour>()); return true;
59700 case 11: v(var.as<UE_X2AP_ID_Extension>()); return true;
59701 case 12: v(var.as<SplitSRBs>()); return true;
59702 case 13: v(var.as<MeNBResourceCoordinationInformation>()); return true;
59703 case 14: v(var.as<SGNB_Addition_Trigger_Ind>()); return true;
59704 case 15: v(var.as<SubscriberProfileIDforRFP>()); return true;
59705 case 16: v(var.as<ECGI>()); return true;
59711 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
59712 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
59715 char dummy1[sizeof(ECGI)];
59716 char dummy2[sizeof(E_RABs_ToBeAdded_SgNBAddReqList)];
59717 char dummy3[sizeof(ExpectedUEBehaviour)];
59718 char dummy4[sizeof(HandoverRestrictionList)];
59719 char dummy5[sizeof(MeNBResourceCoordinationInformation)];
59720 char dummy6[sizeof(MeNBtoSgNBContainer)];
59721 char dummy7[sizeof(NRUESecurityCapabilities)];
59722 char dummy8[sizeof(PLMN_Identity)];
59723 char dummy9[sizeof(SGNB_Addition_Trigger_Ind)];
59724 char dummy10[sizeof(SgNBSecurityKey)];
59725 char dummy11[sizeof(SgNB_UE_X2AP_ID)];
59726 char dummy12[sizeof(SplitSRBs)];
59727 char dummy13[sizeof(SubscriberProfileIDforRFP)];
59728 char dummy14[sizeof(UEAggregateMaximumBitRate)];
59729 char dummy15[sizeof(UE_X2AP_ID)];
59730 char dummy16[sizeof(UE_X2AP_ID_Extension)];
59733 asn::variant<sizeof(union_type)> var;
59737 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
59739 size_t get_index() const {return type;}
59740 bool is_unknown() const { return type == 17; }
59741 void clear() {type = 0;}
59742 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
59743 void select_id_NRUESecurityCapabilities() { set(mandatory); type=2;}
59744 void select_id_SgNBSecurityKey() { set(mandatory); type=3;}
59745 void select_id_SgNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
59746 void select_id_SelectedPLMN() { set(optional); type=5;}
59747 void select_id_HandoverRestrictionList() { set(optional); type=6;}
59748 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(mandatory); type=7;}
59749 void select_id_MeNBtoSgNBContainer() { set(mandatory); type=8;}
59750 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=9;}
59751 void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
59752 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=11;}
59753 void select_id_RequestedSplitSRBs() { set(optional); type=12;}
59754 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=13;}
59755 void select_id_SGNB_Addition_Trigger_Ind() { set(optional); type=14;}
59756 void select_id_SubscriberProfileIDforRFP() { set(optional); type=15;}
59757 void select_id_MeNBCell_ID() { set(mandatory); type=16;}
59758 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
59759 template<typename V> bool decode(V& v)
59762 if(!v(ref_nested())) return false;
59763 if(equal(mandatory)) { type = 1; return true; }
59764 else if(equal(mandatory)) { type = 2; return true; }
59765 else if(equal(mandatory)) { type = 3; return true; }
59766 else if(equal(mandatory)) { type = 4; return true; }
59767 else if(equal(optional)) { type = 5; return true; }
59768 else if(equal(optional)) { type = 6; return true; }
59769 else if(equal(mandatory)) { type = 7; return true; }
59770 else if(equal(mandatory)) { type = 8; return true; }
59771 else if(equal(optional)) { type = 9; return true; }
59772 else if(equal(optional)) { type = 10; return true; }
59773 else if(equal(optional)) { type = 11; return true; }
59774 else if(equal(optional)) { type = 12; return true; }
59775 else if(equal(optional)) { type = 13; return true; }
59776 else if(equal(optional)) { type = 14; return true; }
59777 else if(equal(optional)) { type = 15; return true; }
59778 else if(equal(mandatory)) { type = 16; return true; }
59779 else { type = 17; return true;}
59783 template<typename V> bool encode(V& v) const
59785 return v(ref_nested());
59789 template<typename V> bool decode(size_t index, V& v)
59794 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59795 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59796 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
59797 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
59798 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
59799 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
59800 case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} return false;
59801 case 8: type = 8; if(v(ref_nested())) { return equal(mandatory);} return false;
59802 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
59803 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
59804 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
59805 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
59806 case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
59807 case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
59808 case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
59809 case 16: type = 16; if(v(ref_nested())) { return equal(mandatory);} return false;
59810 case 17: type = 17; return v(ref_nested());
59811 ref_nested().clear();
59816 template<typename V> bool encode(size_t index, V& v) const
59818 if(index != type) {return false;} return v(ref_nested());
59828 SgNBAdditionRequest ::= SEQUENCE {
59829 protocolIEs ProtocolIE-Container {{SgNBAdditionRequest-IEs}},
59834 struct SgNBAdditionRequest : asn::sequence<1, 0, true, 0>
59836 static constexpr const char* name() {return "SgNBAdditionRequest";}
59837 using parent_t = asn::sequence<1, 0, true, 0>;
59838 struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequest_IEs>
59840 static constexpr const char* name() {return "protocolIEs_t";}
59841 using parent_t = ProtocolIE_Container<SgNBAdditionRequest_IEs>;
59844 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59845 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59846 template<typename V> void decode(V& v)
59851 template<typename V> void encode(V& v) const
59858 protocolIEs.clear();
59862 protocolIEs_t protocolIEs;
59866 SgNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
59867 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
59868 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
59869 { ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList PRESENCE mandatory}|
59870 { ID id-E-RABs-NotAdmitted-List CRITICALITY ignore TYPE E-RAB-List PRESENCE optional}|
59871 { ID id-SgNBtoMeNBContainer CRITICALITY reject TYPE SgNBtoMeNBContainer PRESENCE mandatory}|
59872 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
59873 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
59874 { ID id-AdmittedSplitSRBs CRITICALITY reject TYPE SplitSRBs PRESENCE optional}|
59875 { ID id-SgNBResourceCoordinationInformation CRITICALITY ignore TYPE SgNBResourceCoordinationInformation PRESENCE optional}|
59876 { ID id-RRCConfigIndication CRITICALITY reject TYPE RRC-Config-Ind PRESENCE optional},
59881 struct SgNBAdditionRequestAcknowledge_IEs
59883 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59885 size_t get_index() const {return type;}
59886 bool is_unknown() const { return type == 11; }
59887 void clear() {type = 0;}
59888 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59889 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
59890 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList); type=3;}
59891 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
59892 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
59893 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
59894 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
59895 void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=8;}
59896 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
59897 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
59898 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59899 template<typename V> bool decode(V& v)
59902 if(!v(ref_nested())) return false;
59903 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59904 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
59905 else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)) { type = 3; return true; }
59906 else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
59907 else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
59908 else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
59909 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
59910 else if(equal(id_AdmittedSplitSRBs)) { type = 8; return true; }
59911 else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
59912 else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
59913 else { type = 11; return true;}
59917 template<typename V> bool encode(V& v) const
59919 return v(ref_nested());
59923 template<typename V> bool decode(size_t index, V& v)
59928 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59929 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59930 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);} return false;
59931 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
59932 case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
59933 case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
59934 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59935 case 8: type = 8; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
59936 case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
59937 case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
59938 case 11: type = 11; return v(ref_nested());
59939 ref_nested().clear();
59944 template<typename V> bool encode(size_t index, V& v) const
59946 if(index != type) {return false;} return v(ref_nested());
59953 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59955 size_t get_index() const {return type;}
59956 bool is_unknown() const { return type == 11; }
59957 void clear() {type = 0;}
59958 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59959 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
59960 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(ignore); type=3;}
59961 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
59962 void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
59963 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
59964 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
59965 void select_id_AdmittedSplitSRBs() { set(reject); type=8;}
59966 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
59967 void select_id_RRCConfigIndication() { set(reject); type=10;}
59968 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59969 template<typename V> bool decode(V& v)
59972 if(!v(ref_nested())) return false;
59973 if(equal(reject)) { type = 1; return true; }
59974 else if(equal(reject)) { type = 2; return true; }
59975 else if(equal(ignore)) { type = 3; return true; }
59976 else if(equal(ignore)) { type = 4; return true; }
59977 else if(equal(reject)) { type = 5; return true; }
59978 else if(equal(ignore)) { type = 6; return true; }
59979 else if(equal(reject)) { type = 7; return true; }
59980 else if(equal(reject)) { type = 8; return true; }
59981 else if(equal(ignore)) { type = 9; return true; }
59982 else if(equal(reject)) { type = 10; return true; }
59983 else { type = 11; return true;}
59987 template<typename V> bool encode(V& v) const
59989 return v(ref_nested());
59993 template<typename V> bool decode(size_t index, V& v)
59998 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59999 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
60000 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60001 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60002 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60003 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
60004 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
60005 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
60006 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
60007 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
60008 case 11: type = 11; return v(ref_nested());
60009 ref_nested().clear();
60014 template<typename V> bool encode(size_t index, V& v) const
60016 if(index != type) {return false;} return v(ref_nested());
60023 struct Value_t : asn::typefield<true>
60025 ~Value_t() {clear();}
60026 size_t get_index() const {return type;}
60027 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60028 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60029 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60030 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60031 E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
60032 E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
60033 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
60034 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
60035 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
60036 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
60037 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
60038 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
60039 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
60040 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
60041 SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(8); }
60042 SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(8); }
60043 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
60044 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
60045 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
60046 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
60047 bool is_unknown() const { return type == 11; }
60052 case 1: var.destroy<UE_X2AP_ID>(); break;
60053 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60054 case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(); break;
60055 case 4: var.destroy<E_RAB_List>(); break;
60056 case 5: var.destroy<SgNBtoMeNBContainer>(); break;
60057 case 6: var.destroy<CriticalityDiagnostics>(); break;
60058 case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
60059 case 8: var.destroy<SplitSRBs>(); break;
60060 case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
60061 case 10: var.destroy<RRC_Config_Ind>(); break;
60063 type = 0; ref_nested().clear();
60065 template<typename V> static inline void enumerate(V& v)
60067 v.template operator()<UE_X2AP_ID>(1);
60068 v.template operator()<SgNB_UE_X2AP_ID>(2);
60069 v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3);
60070 v.template operator()<E_RAB_List>(4);
60071 v.template operator()<SgNBtoMeNBContainer>(5);
60072 v.template operator()<CriticalityDiagnostics>(6);
60073 v.template operator()<UE_X2AP_ID_Extension>(7);
60074 v.template operator()<SplitSRBs>(8);
60075 v.template operator()<SgNBResourceCoordinationInformation>(9);
60076 v.template operator()<RRC_Config_Ind>(10);
60080 template<typename V> bool decode(size_t index, V& v)
60085 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60086 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60087 case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList()); return true;
60088 case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
60089 case 5: v(select_id_SgNBtoMeNBContainer()); return true;
60090 case 6: v(select_id_CriticalityDiagnostics()); return true;
60091 case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60092 case 8: v(select_id_AdmittedSplitSRBs()); return true;
60093 case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
60094 case 10: v(select_id_RRCConfigIndication()); return true;
60095 case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
60100 template<typename V> bool encode(size_t index, V& v) const
60102 if(index != type) return false;
60105 case 1: v(var.as<UE_X2AP_ID>()); return true;
60106 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60107 case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>()); return true;
60108 case 4: v(var.as<E_RAB_List>()); return true;
60109 case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
60110 case 6: v(var.as<CriticalityDiagnostics>()); return true;
60111 case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
60112 case 8: v(var.as<SplitSRBs>()); return true;
60113 case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
60114 case 10: v(var.as<RRC_Config_Ind>()); return true;
60120 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60121 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60124 char dummy1[sizeof(CriticalityDiagnostics)];
60125 char dummy2[sizeof(E_RAB_List)];
60126 char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)];
60127 char dummy4[sizeof(RRC_Config_Ind)];
60128 char dummy5[sizeof(SgNBResourceCoordinationInformation)];
60129 char dummy6[sizeof(SgNB_UE_X2AP_ID)];
60130 char dummy7[sizeof(SgNBtoMeNBContainer)];
60131 char dummy8[sizeof(SplitSRBs)];
60132 char dummy9[sizeof(UE_X2AP_ID)];
60133 char dummy10[sizeof(UE_X2AP_ID_Extension)];
60136 asn::variant<sizeof(union_type)> var;
60140 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60142 size_t get_index() const {return type;}
60143 bool is_unknown() const { return type == 11; }
60144 void clear() {type = 0;}
60145 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60146 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
60147 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(mandatory); type=3;}
60148 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
60149 void select_id_SgNBtoMeNBContainer() { set(mandatory); type=5;}
60150 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
60151 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
60152 void select_id_AdmittedSplitSRBs() { set(optional); type=8;}
60153 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
60154 void select_id_RRCConfigIndication() { set(optional); type=10;}
60155 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60156 template<typename V> bool decode(V& v)
60159 if(!v(ref_nested())) return false;
60160 if(equal(mandatory)) { type = 1; return true; }
60161 else if(equal(mandatory)) { type = 2; return true; }
60162 else if(equal(mandatory)) { type = 3; return true; }
60163 else if(equal(optional)) { type = 4; return true; }
60164 else if(equal(mandatory)) { type = 5; return true; }
60165 else if(equal(optional)) { type = 6; return true; }
60166 else if(equal(optional)) { type = 7; return true; }
60167 else if(equal(optional)) { type = 8; return true; }
60168 else if(equal(optional)) { type = 9; return true; }
60169 else if(equal(optional)) { type = 10; return true; }
60170 else { type = 11; return true;}
60174 template<typename V> bool encode(V& v) const
60176 return v(ref_nested());
60180 template<typename V> bool decode(size_t index, V& v)
60185 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60186 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
60187 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
60188 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60189 case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
60190 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
60191 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
60192 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
60193 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
60194 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
60195 case 11: type = 11; return v(ref_nested());
60196 ref_nested().clear();
60201 template<typename V> bool encode(size_t index, V& v) const
60203 if(index != type) {return false;} return v(ref_nested());
60213 SgNBAdditionRequestAcknowledge ::= SEQUENCE {
60214 protocolIEs ProtocolIE-Container {{SgNBAdditionRequestAcknowledge-IEs}},
60219 struct SgNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
60221 static constexpr const char* name() {return "SgNBAdditionRequestAcknowledge";}
60222 using parent_t = asn::sequence<1, 0, true, 0>;
60223 struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>
60225 static constexpr const char* name() {return "protocolIEs_t";}
60226 using parent_t = ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>;
60229 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60230 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60231 template<typename V> void decode(V& v)
60236 template<typename V> void encode(V& v) const
60243 protocolIEs.clear();
60247 protocolIEs_t protocolIEs;
60251 SgNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
60252 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
60253 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE optional}|
60254 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
60255 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
60256 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
60261 struct SgNBAdditionRequestReject_IEs
60263 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60265 size_t get_index() const {return type;}
60266 bool is_unknown() const { return type == 6; }
60267 void clear() {type = 0;}
60268 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60269 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60270 void select_id_Cause() { set(id_Cause); type=3;}
60271 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60272 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60273 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60274 template<typename V> bool decode(V& v)
60277 if(!v(ref_nested())) return false;
60278 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60279 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60280 else if(equal(id_Cause)) { type = 3; return true; }
60281 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60282 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60283 else { type = 6; return true;}
60287 template<typename V> bool encode(V& v) const
60289 return v(ref_nested());
60293 template<typename V> bool decode(size_t index, V& v)
60298 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60299 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60300 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
60301 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60302 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60303 case 6: type = 6; return v(ref_nested());
60304 ref_nested().clear();
60309 template<typename V> bool encode(size_t index, V& v) const
60311 if(index != type) {return false;} return v(ref_nested());
60318 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60320 size_t get_index() const {return type;}
60321 bool is_unknown() const { return type == 6; }
60322 void clear() {type = 0;}
60323 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
60324 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
60325 void select_id_Cause() { set(ignore); type=3;}
60326 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60327 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
60328 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60329 template<typename V> bool decode(V& v)
60332 if(!v(ref_nested())) return false;
60333 if(equal(reject)) { type = 1; return true; }
60334 else if(equal(reject)) { type = 2; return true; }
60335 else if(equal(ignore)) { type = 3; return true; }
60336 else if(equal(ignore)) { type = 4; return true; }
60337 else if(equal(reject)) { type = 5; return true; }
60338 else { type = 6; return true;}
60342 template<typename V> bool encode(V& v) const
60344 return v(ref_nested());
60348 template<typename V> bool decode(size_t index, V& v)
60353 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
60354 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
60355 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60356 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60357 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60358 case 6: type = 6; return v(ref_nested());
60359 ref_nested().clear();
60364 template<typename V> bool encode(size_t index, V& v) const
60366 if(index != type) {return false;} return v(ref_nested());
60373 struct Value_t : asn::typefield<true>
60375 ~Value_t() {clear();}
60376 size_t get_index() const {return type;}
60377 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60378 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60379 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60380 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60381 Cause& select_id_Cause() { return set<Cause>(3); }
60382 Cause const* get_id_Cause() const { return get<Cause>(3); }
60383 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60384 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60385 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60386 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60387 bool is_unknown() const { return type == 6; }
60392 case 1: var.destroy<UE_X2AP_ID>(); break;
60393 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60394 case 3: var.destroy<Cause>(); break;
60395 case 4: var.destroy<CriticalityDiagnostics>(); break;
60396 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60398 type = 0; ref_nested().clear();
60400 template<typename V> static inline void enumerate(V& v)
60402 v.template operator()<UE_X2AP_ID>(1);
60403 v.template operator()<SgNB_UE_X2AP_ID>(2);
60404 v.template operator()<Cause>(3);
60405 v.template operator()<CriticalityDiagnostics>(4);
60406 v.template operator()<UE_X2AP_ID_Extension>(5);
60410 template<typename V> bool decode(size_t index, V& v)
60415 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60416 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60417 case 3: v(select_id_Cause()); return true;
60418 case 4: v(select_id_CriticalityDiagnostics()); return true;
60419 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60420 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
60425 template<typename V> bool encode(size_t index, V& v) const
60427 if(index != type) return false;
60430 case 1: v(var.as<UE_X2AP_ID>()); return true;
60431 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60432 case 3: v(var.as<Cause>()); return true;
60433 case 4: v(var.as<CriticalityDiagnostics>()); return true;
60434 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
60440 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60441 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60444 char dummy1[sizeof(Cause)];
60445 char dummy2[sizeof(CriticalityDiagnostics)];
60446 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
60447 char dummy4[sizeof(UE_X2AP_ID)];
60448 char dummy5[sizeof(UE_X2AP_ID_Extension)];
60451 asn::variant<sizeof(union_type)> var;
60455 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60457 size_t get_index() const {return type;}
60458 bool is_unknown() const { return type == 6; }
60459 void clear() {type = 0;}
60460 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60461 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
60462 void select_id_Cause() { set(mandatory); type=3;}
60463 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
60464 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
60465 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60466 template<typename V> bool decode(V& v)
60469 if(!v(ref_nested())) return false;
60470 if(equal(mandatory)) { type = 1; return true; }
60471 else if(equal(optional)) { type = 2; return true; }
60472 else if(equal(mandatory)) { type = 3; return true; }
60473 else if(equal(optional)) { type = 4; return true; }
60474 else if(equal(optional)) { type = 5; return true; }
60475 else { type = 6; return true;}
60479 template<typename V> bool encode(V& v) const
60481 return v(ref_nested());
60485 template<typename V> bool decode(size_t index, V& v)
60490 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60491 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
60492 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
60493 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60494 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
60495 case 6: type = 6; return v(ref_nested());
60496 ref_nested().clear();
60501 template<typename V> bool encode(size_t index, V& v) const
60503 if(index != type) {return false;} return v(ref_nested());
60513 SgNBAdditionRequestReject ::= SEQUENCE {
60514 protocolIEs ProtocolIE-Container {{SgNBAdditionRequestReject-IEs}},
60519 struct SgNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
60521 static constexpr const char* name() {return "SgNBAdditionRequestReject";}
60522 using parent_t = asn::sequence<1, 0, true, 0>;
60523 struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestReject_IEs>
60525 static constexpr const char* name() {return "protocolIEs_t";}
60526 using parent_t = ProtocolIE_Container<SgNBAdditionRequestReject_IEs>;
60529 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60530 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60531 template<typename V> void decode(V& v)
60536 template<typename V> void encode(V& v) const
60543 protocolIEs.clear();
60547 protocolIEs_t protocolIEs;
60551 SgNBChangeConfirm-IEs X2AP-PROTOCOL-IES ::= {
60552 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
60553 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
60554 { ID id-E-RABs-ToBeReleased-SgNBChaConfList CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBChaConfList PRESENCE optional}|
60555 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
60556 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
60561 struct SgNBChangeConfirm_IEs
60563 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60565 size_t get_index() const {return type;}
60566 bool is_unknown() const { return type == 6; }
60567 void clear() {type = 0;}
60568 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60569 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60570 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(id_E_RABs_ToBeReleased_SgNBChaConfList); type=3;}
60571 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60572 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60573 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60574 template<typename V> bool decode(V& v)
60577 if(!v(ref_nested())) return false;
60578 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60579 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60580 else if(equal(id_E_RABs_ToBeReleased_SgNBChaConfList)) { type = 3; return true; }
60581 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60582 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60583 else { type = 6; return true;}
60587 template<typename V> bool encode(V& v) const
60589 return v(ref_nested());
60593 template<typename V> bool decode(size_t index, V& v)
60598 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60599 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60600 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBChaConfList);} return false;
60601 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60602 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60603 case 6: type = 6; return v(ref_nested());
60604 ref_nested().clear();
60609 template<typename V> bool encode(size_t index, V& v) const
60611 if(index != type) {return false;} return v(ref_nested());
60618 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60620 size_t get_index() const {return type;}
60621 bool is_unknown() const { return type == 6; }
60622 void clear() {type = 0;}
60623 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
60624 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
60625 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(ignore); type=3;}
60626 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60627 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
60628 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60629 template<typename V> bool decode(V& v)
60632 if(!v(ref_nested())) return false;
60633 if(equal(ignore)) { type = 1; return true; }
60634 else if(equal(ignore)) { type = 2; return true; }
60635 else if(equal(ignore)) { type = 3; return true; }
60636 else if(equal(ignore)) { type = 4; return true; }
60637 else if(equal(ignore)) { type = 5; return true; }
60638 else { type = 6; return true;}
60642 template<typename V> bool encode(V& v) const
60644 return v(ref_nested());
60648 template<typename V> bool decode(size_t index, V& v)
60653 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
60654 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
60655 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60656 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60657 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
60658 case 6: type = 6; return v(ref_nested());
60659 ref_nested().clear();
60664 template<typename V> bool encode(size_t index, V& v) const
60666 if(index != type) {return false;} return v(ref_nested());
60673 struct Value_t : asn::typefield<true>
60675 ~Value_t() {clear();}
60676 size_t get_index() const {return type;}
60677 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60678 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60679 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60680 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60681 E_RABs_ToBeReleased_SgNBChaConfList& select_id_E_RABs_ToBeReleased_SgNBChaConfList() { return set<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
60682 E_RABs_ToBeReleased_SgNBChaConfList const* get_id_E_RABs_ToBeReleased_SgNBChaConfList() const { return get<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
60683 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60684 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60685 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60686 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60687 bool is_unknown() const { return type == 6; }
60692 case 1: var.destroy<UE_X2AP_ID>(); break;
60693 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60694 case 3: var.destroy<E_RABs_ToBeReleased_SgNBChaConfList>(); break;
60695 case 4: var.destroy<CriticalityDiagnostics>(); break;
60696 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60698 type = 0; ref_nested().clear();
60700 template<typename V> static inline void enumerate(V& v)
60702 v.template operator()<UE_X2AP_ID>(1);
60703 v.template operator()<SgNB_UE_X2AP_ID>(2);
60704 v.template operator()<E_RABs_ToBeReleased_SgNBChaConfList>(3);
60705 v.template operator()<CriticalityDiagnostics>(4);
60706 v.template operator()<UE_X2AP_ID_Extension>(5);
60710 template<typename V> bool decode(size_t index, V& v)
60715 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60716 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60717 case 3: v(select_id_E_RABs_ToBeReleased_SgNBChaConfList()); return true;
60718 case 4: v(select_id_CriticalityDiagnostics()); return true;
60719 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60720 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
60725 template<typename V> bool encode(size_t index, V& v) const
60727 if(index != type) return false;
60730 case 1: v(var.as<UE_X2AP_ID>()); return true;
60731 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60732 case 3: v(var.as<E_RABs_ToBeReleased_SgNBChaConfList>()); return true;
60733 case 4: v(var.as<CriticalityDiagnostics>()); return true;
60734 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
60740 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60741 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60744 char dummy1[sizeof(CriticalityDiagnostics)];
60745 char dummy2[sizeof(E_RABs_ToBeReleased_SgNBChaConfList)];
60746 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
60747 char dummy4[sizeof(UE_X2AP_ID)];
60748 char dummy5[sizeof(UE_X2AP_ID_Extension)];
60751 asn::variant<sizeof(union_type)> var;
60755 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60757 size_t get_index() const {return type;}
60758 bool is_unknown() const { return type == 6; }
60759 void clear() {type = 0;}
60760 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60761 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
60762 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(optional); type=3;}
60763 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
60764 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
60765 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60766 template<typename V> bool decode(V& v)
60769 if(!v(ref_nested())) return false;
60770 if(equal(mandatory)) { type = 1; return true; }
60771 else if(equal(mandatory)) { type = 2; return true; }
60772 else if(equal(optional)) { type = 3; return true; }
60773 else if(equal(optional)) { type = 4; return true; }
60774 else if(equal(optional)) { type = 5; return true; }
60775 else { type = 6; return true;}
60779 template<typename V> bool encode(V& v) const
60781 return v(ref_nested());
60785 template<typename V> bool decode(size_t index, V& v)
60790 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60791 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
60792 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
60793 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60794 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
60795 case 6: type = 6; return v(ref_nested());
60796 ref_nested().clear();
60801 template<typename V> bool encode(size_t index, V& v) const
60803 if(index != type) {return false;} return v(ref_nested());
60813 SgNBChangeConfirm ::= SEQUENCE {
60814 protocolIEs ProtocolIE-Container {{SgNBChangeConfirm-IEs}},
60819 struct SgNBChangeConfirm : asn::sequence<1, 0, true, 0>
60821 static constexpr const char* name() {return "SgNBChangeConfirm";}
60822 using parent_t = asn::sequence<1, 0, true, 0>;
60823 struct protocolIEs_t : ProtocolIE_Container<SgNBChangeConfirm_IEs>
60825 static constexpr const char* name() {return "protocolIEs_t";}
60826 using parent_t = ProtocolIE_Container<SgNBChangeConfirm_IEs>;
60829 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60830 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60831 template<typename V> void decode(V& v)
60836 template<typename V> void encode(V& v) const
60843 protocolIEs.clear();
60847 protocolIEs_t protocolIEs;
60851 SgNBChangeRefuse-IEs X2AP-PROTOCOL-IES ::= {
60852 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
60853 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
60854 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
60855 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
60856 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
60861 struct SgNBChangeRefuse_IEs
60863 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60865 size_t get_index() const {return type;}
60866 bool is_unknown() const { return type == 6; }
60867 void clear() {type = 0;}
60868 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60869 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60870 void select_id_Cause() { set(id_Cause); type=3;}
60871 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60872 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60873 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60874 template<typename V> bool decode(V& v)
60877 if(!v(ref_nested())) return false;
60878 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60879 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60880 else if(equal(id_Cause)) { type = 3; return true; }
60881 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60882 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60883 else { type = 6; return true;}
60887 template<typename V> bool encode(V& v) const
60889 return v(ref_nested());
60893 template<typename V> bool decode(size_t index, V& v)
60898 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60899 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60900 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
60901 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60902 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60903 case 6: type = 6; return v(ref_nested());
60904 ref_nested().clear();
60909 template<typename V> bool encode(size_t index, V& v) const
60911 if(index != type) {return false;} return v(ref_nested());
60918 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60920 size_t get_index() const {return type;}
60921 bool is_unknown() const { return type == 6; }
60922 void clear() {type = 0;}
60923 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
60924 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
60925 void select_id_Cause() { set(ignore); type=3;}
60926 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60927 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
60928 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60929 template<typename V> bool decode(V& v)
60932 if(!v(ref_nested())) return false;
60933 if(equal(ignore)) { type = 1; return true; }
60934 else if(equal(ignore)) { type = 2; return true; }
60935 else if(equal(ignore)) { type = 3; return true; }
60936 else if(equal(ignore)) { type = 4; return true; }
60937 else if(equal(reject)) { type = 5; return true; }
60938 else { type = 6; return true;}
60942 template<typename V> bool encode(V& v) const
60944 return v(ref_nested());
60948 template<typename V> bool decode(size_t index, V& v)
60953 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
60954 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
60955 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60956 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60957 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60958 case 6: type = 6; return v(ref_nested());
60959 ref_nested().clear();
60964 template<typename V> bool encode(size_t index, V& v) const
60966 if(index != type) {return false;} return v(ref_nested());
60973 struct Value_t : asn::typefield<true>
60975 ~Value_t() {clear();}
60976 size_t get_index() const {return type;}
60977 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60978 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60979 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60980 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60981 Cause& select_id_Cause() { return set<Cause>(3); }
60982 Cause const* get_id_Cause() const { return get<Cause>(3); }
60983 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60984 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60985 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60986 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60987 bool is_unknown() const { return type == 6; }
60992 case 1: var.destroy<UE_X2AP_ID>(); break;
60993 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60994 case 3: var.destroy<Cause>(); break;
60995 case 4: var.destroy<CriticalityDiagnostics>(); break;
60996 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60998 type = 0; ref_nested().clear();
61000 template<typename V> static inline void enumerate(V& v)
61002 v.template operator()<UE_X2AP_ID>(1);
61003 v.template operator()<SgNB_UE_X2AP_ID>(2);
61004 v.template operator()<Cause>(3);
61005 v.template operator()<CriticalityDiagnostics>(4);
61006 v.template operator()<UE_X2AP_ID_Extension>(5);
61010 template<typename V> bool decode(size_t index, V& v)
61015 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61016 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61017 case 3: v(select_id_Cause()); return true;
61018 case 4: v(select_id_CriticalityDiagnostics()); return true;
61019 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61020 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
61025 template<typename V> bool encode(size_t index, V& v) const
61027 if(index != type) return false;
61030 case 1: v(var.as<UE_X2AP_ID>()); return true;
61031 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61032 case 3: v(var.as<Cause>()); return true;
61033 case 4: v(var.as<CriticalityDiagnostics>()); return true;
61034 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
61040 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61041 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61044 char dummy1[sizeof(Cause)];
61045 char dummy2[sizeof(CriticalityDiagnostics)];
61046 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
61047 char dummy4[sizeof(UE_X2AP_ID)];
61048 char dummy5[sizeof(UE_X2AP_ID_Extension)];
61051 asn::variant<sizeof(union_type)> var;
61055 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61057 size_t get_index() const {return type;}
61058 bool is_unknown() const { return type == 6; }
61059 void clear() {type = 0;}
61060 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61061 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61062 void select_id_Cause() { set(mandatory); type=3;}
61063 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
61064 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
61065 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61066 template<typename V> bool decode(V& v)
61069 if(!v(ref_nested())) return false;
61070 if(equal(mandatory)) { type = 1; return true; }
61071 else if(equal(mandatory)) { type = 2; return true; }
61072 else if(equal(mandatory)) { type = 3; return true; }
61073 else if(equal(optional)) { type = 4; return true; }
61074 else if(equal(optional)) { type = 5; return true; }
61075 else { type = 6; return true;}
61079 template<typename V> bool encode(V& v) const
61081 return v(ref_nested());
61085 template<typename V> bool decode(size_t index, V& v)
61090 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61091 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61092 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61093 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
61094 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
61095 case 6: type = 6; return v(ref_nested());
61096 ref_nested().clear();
61101 template<typename V> bool encode(size_t index, V& v) const
61103 if(index != type) {return false;} return v(ref_nested());
61113 SgNBChangeRefuse ::= SEQUENCE {
61114 protocolIEs ProtocolIE-Container {{SgNBChangeRefuse-IEs}},
61119 struct SgNBChangeRefuse : asn::sequence<1, 0, true, 0>
61121 static constexpr const char* name() {return "SgNBChangeRefuse";}
61122 using parent_t = asn::sequence<1, 0, true, 0>;
61123 struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRefuse_IEs>
61125 static constexpr const char* name() {return "protocolIEs_t";}
61126 using parent_t = ProtocolIE_Container<SgNBChangeRefuse_IEs>;
61129 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61130 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61131 template<typename V> void decode(V& v)
61136 template<typename V> void encode(V& v) const
61143 protocolIEs.clear();
61147 protocolIEs_t protocolIEs;
61151 SgNBChangeRequired-IEs X2AP-PROTOCOL-IES ::= {
61152 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
61153 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
61154 { ID id-Target-SgNB-ID CRITICALITY reject TYPE GlobalGNB-ID PRESENCE mandatory}|
61155 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
61156 { ID id-SgNBtoMeNBContainer CRITICALITY reject TYPE SgNBtoMeNBContainer PRESENCE optional}|
61157 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
61162 struct SgNBChangeRequired_IEs
61164 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61166 size_t get_index() const {return type;}
61167 bool is_unknown() const { return type == 7; }
61168 void clear() {type = 0;}
61169 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61170 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61171 void select_id_Target_SgNB_ID() { set(id_Target_SgNB_ID); type=3;}
61172 void select_id_Cause() { set(id_Cause); type=4;}
61173 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
61174 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
61175 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61176 template<typename V> bool decode(V& v)
61179 if(!v(ref_nested())) return false;
61180 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61181 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61182 else if(equal(id_Target_SgNB_ID)) { type = 3; return true; }
61183 else if(equal(id_Cause)) { type = 4; return true; }
61184 else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
61185 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
61186 else { type = 7; return true;}
61190 template<typename V> bool encode(V& v) const
61192 return v(ref_nested());
61196 template<typename V> bool decode(size_t index, V& v)
61201 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61202 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61203 case 3: type = 3; if(v(ref_nested())) { return equal(id_Target_SgNB_ID);} return false;
61204 case 4: type = 4; if(v(ref_nested())) { return equal(id_Cause);} return false;
61205 case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
61206 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61207 case 7: type = 7; return v(ref_nested());
61208 ref_nested().clear();
61213 template<typename V> bool encode(size_t index, V& v) const
61215 if(index != type) {return false;} return v(ref_nested());
61222 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61224 size_t get_index() const {return type;}
61225 bool is_unknown() const { return type == 7; }
61226 void clear() {type = 0;}
61227 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
61228 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
61229 void select_id_Target_SgNB_ID() { set(reject); type=3;}
61230 void select_id_Cause() { set(ignore); type=4;}
61231 void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
61232 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
61233 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61234 template<typename V> bool decode(V& v)
61237 if(!v(ref_nested())) return false;
61238 if(equal(reject)) { type = 1; return true; }
61239 else if(equal(reject)) { type = 2; return true; }
61240 else if(equal(reject)) { type = 3; return true; }
61241 else if(equal(ignore)) { type = 4; return true; }
61242 else if(equal(reject)) { type = 5; return true; }
61243 else if(equal(reject)) { type = 6; return true; }
61244 else { type = 7; return true;}
61248 template<typename V> bool encode(V& v) const
61250 return v(ref_nested());
61254 template<typename V> bool decode(size_t index, V& v)
61259 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
61260 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
61261 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
61262 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61263 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
61264 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
61265 case 7: type = 7; return v(ref_nested());
61266 ref_nested().clear();
61271 template<typename V> bool encode(size_t index, V& v) const
61273 if(index != type) {return false;} return v(ref_nested());
61280 struct Value_t : asn::typefield<true>
61282 ~Value_t() {clear();}
61283 size_t get_index() const {return type;}
61284 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61285 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61286 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61287 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61288 GlobalGNB_ID& select_id_Target_SgNB_ID() { return set<GlobalGNB_ID>(3); }
61289 GlobalGNB_ID const* get_id_Target_SgNB_ID() const { return get<GlobalGNB_ID>(3); }
61290 Cause& select_id_Cause() { return set<Cause>(4); }
61291 Cause const* get_id_Cause() const { return get<Cause>(4); }
61292 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
61293 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
61294 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
61295 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
61296 bool is_unknown() const { return type == 7; }
61301 case 1: var.destroy<UE_X2AP_ID>(); break;
61302 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61303 case 3: var.destroy<GlobalGNB_ID>(); break;
61304 case 4: var.destroy<Cause>(); break;
61305 case 5: var.destroy<SgNBtoMeNBContainer>(); break;
61306 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
61308 type = 0; ref_nested().clear();
61310 template<typename V> static inline void enumerate(V& v)
61312 v.template operator()<UE_X2AP_ID>(1);
61313 v.template operator()<SgNB_UE_X2AP_ID>(2);
61314 v.template operator()<GlobalGNB_ID>(3);
61315 v.template operator()<Cause>(4);
61316 v.template operator()<SgNBtoMeNBContainer>(5);
61317 v.template operator()<UE_X2AP_ID_Extension>(6);
61321 template<typename V> bool decode(size_t index, V& v)
61326 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61327 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61328 case 3: v(select_id_Target_SgNB_ID()); return true;
61329 case 4: v(select_id_Cause()); return true;
61330 case 5: v(select_id_SgNBtoMeNBContainer()); return true;
61331 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61332 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
61337 template<typename V> bool encode(size_t index, V& v) const
61339 if(index != type) return false;
61342 case 1: v(var.as<UE_X2AP_ID>()); return true;
61343 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61344 case 3: v(var.as<GlobalGNB_ID>()); return true;
61345 case 4: v(var.as<Cause>()); return true;
61346 case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
61347 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
61353 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61354 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61357 char dummy1[sizeof(Cause)];
61358 char dummy2[sizeof(GlobalGNB_ID)];
61359 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
61360 char dummy4[sizeof(SgNBtoMeNBContainer)];
61361 char dummy5[sizeof(UE_X2AP_ID)];
61362 char dummy6[sizeof(UE_X2AP_ID_Extension)];
61365 asn::variant<sizeof(union_type)> var;
61369 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61371 size_t get_index() const {return type;}
61372 bool is_unknown() const { return type == 7; }
61373 void clear() {type = 0;}
61374 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61375 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61376 void select_id_Target_SgNB_ID() { set(mandatory); type=3;}
61377 void select_id_Cause() { set(mandatory); type=4;}
61378 void select_id_SgNBtoMeNBContainer() { set(optional); type=5;}
61379 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
61380 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61381 template<typename V> bool decode(V& v)
61384 if(!v(ref_nested())) return false;
61385 if(equal(mandatory)) { type = 1; return true; }
61386 else if(equal(mandatory)) { type = 2; return true; }
61387 else if(equal(mandatory)) { type = 3; return true; }
61388 else if(equal(mandatory)) { type = 4; return true; }
61389 else if(equal(optional)) { type = 5; return true; }
61390 else if(equal(optional)) { type = 6; return true; }
61391 else { type = 7; return true;}
61395 template<typename V> bool encode(V& v) const
61397 return v(ref_nested());
61401 template<typename V> bool decode(size_t index, V& v)
61406 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61407 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61408 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61409 case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
61410 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
61411 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
61412 case 7: type = 7; return v(ref_nested());
61413 ref_nested().clear();
61418 template<typename V> bool encode(size_t index, V& v) const
61420 if(index != type) {return false;} return v(ref_nested());
61430 SgNBChangeRequired ::= SEQUENCE {
61431 protocolIEs ProtocolIE-Container {{SgNBChangeRequired-IEs}},
61436 struct SgNBChangeRequired : asn::sequence<1, 0, true, 0>
61438 static constexpr const char* name() {return "SgNBChangeRequired";}
61439 using parent_t = asn::sequence<1, 0, true, 0>;
61440 struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRequired_IEs>
61442 static constexpr const char* name() {return "protocolIEs_t";}
61443 using parent_t = ProtocolIE_Container<SgNBChangeRequired_IEs>;
61446 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61447 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61448 template<typename V> void decode(V& v)
61453 template<typename V> void encode(V& v) const
61460 protocolIEs.clear();
61464 protocolIEs_t protocolIEs;
61468 SgNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
61469 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
61470 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
61471 { ID id-E-RABs-SubjectToSgNBCounterCheck-List CRITICALITY ignore TYPE E-RABs-SubjectToSgNBCounterCheck-List PRESENCE mandatory}|
61472 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
61477 struct SgNBCounterCheckRequest_IEs
61479 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61481 size_t get_index() const {return type;}
61482 bool is_unknown() const { return type == 5; }
61483 void clear() {type = 0;}
61484 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61485 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61486 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(id_E_RABs_SubjectToSgNBCounterCheck_List); type=3;}
61487 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
61488 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61489 template<typename V> bool decode(V& v)
61492 if(!v(ref_nested())) return false;
61493 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61494 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61495 else if(equal(id_E_RABs_SubjectToSgNBCounterCheck_List)) { type = 3; return true; }
61496 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
61497 else { type = 5; return true;}
61501 template<typename V> bool encode(V& v) const
61503 return v(ref_nested());
61507 template<typename V> bool decode(size_t index, V& v)
61512 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61513 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61514 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToSgNBCounterCheck_List);} return false;
61515 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61516 case 5: type = 5; return v(ref_nested());
61517 ref_nested().clear();
61522 template<typename V> bool encode(size_t index, V& v) const
61524 if(index != type) {return false;} return v(ref_nested());
61531 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61533 size_t get_index() const {return type;}
61534 bool is_unknown() const { return type == 5; }
61535 void clear() {type = 0;}
61536 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
61537 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
61538 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(ignore); type=3;}
61539 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
61540 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61541 template<typename V> bool decode(V& v)
61544 if(!v(ref_nested())) return false;
61545 if(equal(reject)) { type = 1; return true; }
61546 else if(equal(reject)) { type = 2; return true; }
61547 else if(equal(ignore)) { type = 3; return true; }
61548 else if(equal(ignore)) { type = 4; return true; }
61549 else { type = 5; return true;}
61553 template<typename V> bool encode(V& v) const
61555 return v(ref_nested());
61559 template<typename V> bool decode(size_t index, V& v)
61564 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
61565 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
61566 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
61567 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61568 case 5: type = 5; return v(ref_nested());
61569 ref_nested().clear();
61574 template<typename V> bool encode(size_t index, V& v) const
61576 if(index != type) {return false;} return v(ref_nested());
61583 struct Value_t : asn::typefield<true>
61585 ~Value_t() {clear();}
61586 size_t get_index() const {return type;}
61587 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61588 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61589 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61590 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61591 E_RABs_SubjectToSgNBCounterCheck_List& select_id_E_RABs_SubjectToSgNBCounterCheck_List() { return set<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
61592 E_RABs_SubjectToSgNBCounterCheck_List const* get_id_E_RABs_SubjectToSgNBCounterCheck_List() const { return get<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
61593 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
61594 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
61595 bool is_unknown() const { return type == 5; }
61600 case 1: var.destroy<UE_X2AP_ID>(); break;
61601 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61602 case 3: var.destroy<E_RABs_SubjectToSgNBCounterCheck_List>(); break;
61603 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
61605 type = 0; ref_nested().clear();
61607 template<typename V> static inline void enumerate(V& v)
61609 v.template operator()<UE_X2AP_ID>(1);
61610 v.template operator()<SgNB_UE_X2AP_ID>(2);
61611 v.template operator()<E_RABs_SubjectToSgNBCounterCheck_List>(3);
61612 v.template operator()<UE_X2AP_ID_Extension>(4);
61616 template<typename V> bool decode(size_t index, V& v)
61621 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61622 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61623 case 3: v(select_id_E_RABs_SubjectToSgNBCounterCheck_List()); return true;
61624 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61625 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
61630 template<typename V> bool encode(size_t index, V& v) const
61632 if(index != type) return false;
61635 case 1: v(var.as<UE_X2AP_ID>()); return true;
61636 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61637 case 3: v(var.as<E_RABs_SubjectToSgNBCounterCheck_List>()); return true;
61638 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
61644 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61645 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61648 char dummy1[sizeof(E_RABs_SubjectToSgNBCounterCheck_List)];
61649 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
61650 char dummy3[sizeof(UE_X2AP_ID)];
61651 char dummy4[sizeof(UE_X2AP_ID_Extension)];
61654 asn::variant<sizeof(union_type)> var;
61658 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61660 size_t get_index() const {return type;}
61661 bool is_unknown() const { return type == 5; }
61662 void clear() {type = 0;}
61663 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61664 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61665 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(mandatory); type=3;}
61666 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
61667 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61668 template<typename V> bool decode(V& v)
61671 if(!v(ref_nested())) return false;
61672 if(equal(mandatory)) { type = 1; return true; }
61673 else if(equal(mandatory)) { type = 2; return true; }
61674 else if(equal(mandatory)) { type = 3; return true; }
61675 else if(equal(optional)) { type = 4; return true; }
61676 else { type = 5; return true;}
61680 template<typename V> bool encode(V& v) const
61682 return v(ref_nested());
61686 template<typename V> bool decode(size_t index, V& v)
61691 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61692 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61693 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61694 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
61695 case 5: type = 5; return v(ref_nested());
61696 ref_nested().clear();
61701 template<typename V> bool encode(size_t index, V& v) const
61703 if(index != type) {return false;} return v(ref_nested());
61713 SgNBCounterCheckRequest ::= SEQUENCE {
61714 protocolIEs ProtocolIE-Container {{SgNBCounterCheckRequest-IEs}},
61719 struct SgNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
61721 static constexpr const char* name() {return "SgNBCounterCheckRequest";}
61722 using parent_t = asn::sequence<1, 0, true, 0>;
61723 struct protocolIEs_t : ProtocolIE_Container<SgNBCounterCheckRequest_IEs>
61725 static constexpr const char* name() {return "protocolIEs_t";}
61726 using parent_t = ProtocolIE_Container<SgNBCounterCheckRequest_IEs>;
61729 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61730 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61731 template<typename V> void decode(V& v)
61736 template<typename V> void encode(V& v) const
61743 protocolIEs.clear();
61747 protocolIEs_t protocolIEs;
61751 SgNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
61752 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
61753 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
61754 { ID id-E-RABs-AdmittedToBeModified-SgNBModConfList CRITICALITY ignore TYPE E-RABs-AdmittedToBeModified-SgNBModConfList PRESENCE optional}|
61755 { ID id-MeNBtoSgNBContainer CRITICALITY ignore TYPE MeNBtoSgNBContainer PRESENCE optional}|
61756 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
61757 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
61758 { ID id-MeNBResourceCoordinationInformation CRITICALITY ignore TYPE MeNBResourceCoordinationInformation PRESENCE optional},
61763 struct SgNBModificationConfirm_IEs
61765 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61767 size_t get_index() const {return type;}
61768 bool is_unknown() const { return type == 8; }
61769 void clear() {type = 0;}
61770 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61771 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61772 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(id_E_RABs_AdmittedToBeModified_SgNBModConfList); type=3;}
61773 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
61774 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
61775 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
61776 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=7;}
61777 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61778 template<typename V> bool decode(V& v)
61781 if(!v(ref_nested())) return false;
61782 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61783 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61784 else if(equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList)) { type = 3; return true; }
61785 else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
61786 else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
61787 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
61788 else if(equal(id_MeNBResourceCoordinationInformation)) { type = 7; return true; }
61789 else { type = 8; return true;}
61793 template<typename V> bool encode(V& v) const
61795 return v(ref_nested());
61799 template<typename V> bool decode(size_t index, V& v)
61804 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61805 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61806 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList);} return false;
61807 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
61808 case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
61809 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61810 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
61811 case 8: type = 8; return v(ref_nested());
61812 ref_nested().clear();
61817 template<typename V> bool encode(size_t index, V& v) const
61819 if(index != type) {return false;} return v(ref_nested());
61826 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61828 size_t get_index() const {return type;}
61829 bool is_unknown() const { return type == 8; }
61830 void clear() {type = 0;}
61831 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
61832 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
61833 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(ignore); type=3;}
61834 void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
61835 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
61836 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
61837 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=7;}
61838 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61839 template<typename V> bool decode(V& v)
61842 if(!v(ref_nested())) return false;
61843 if(equal(ignore)) { type = 1; return true; }
61844 else if(equal(ignore)) { type = 2; return true; }
61845 else if(equal(ignore)) { type = 3; return true; }
61846 else if(equal(ignore)) { type = 4; return true; }
61847 else if(equal(ignore)) { type = 5; return true; }
61848 else if(equal(ignore)) { type = 6; return true; }
61849 else if(equal(ignore)) { type = 7; return true; }
61850 else { type = 8; return true;}
61854 template<typename V> bool encode(V& v) const
61856 return v(ref_nested());
61860 template<typename V> bool decode(size_t index, V& v)
61865 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
61866 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
61867 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
61868 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61869 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
61870 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
61871 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
61872 case 8: type = 8; return v(ref_nested());
61873 ref_nested().clear();
61878 template<typename V> bool encode(size_t index, V& v) const
61880 if(index != type) {return false;} return v(ref_nested());
61887 struct Value_t : asn::typefield<true>
61889 ~Value_t() {clear();}
61890 size_t get_index() const {return type;}
61891 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61892 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61893 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61894 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61895 E_RABs_AdmittedToBeModified_SgNBModConfList& select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { return set<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
61896 E_RABs_AdmittedToBeModified_SgNBModConfList const* get_id_E_RABs_AdmittedToBeModified_SgNBModConfList() const { return get<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
61897 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
61898 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
61899 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
61900 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
61901 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
61902 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
61903 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(7); }
61904 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(7); }
61905 bool is_unknown() const { return type == 8; }
61910 case 1: var.destroy<UE_X2AP_ID>(); break;
61911 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61912 case 3: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConfList>(); break;
61913 case 4: var.destroy<MeNBtoSgNBContainer>(); break;
61914 case 5: var.destroy<CriticalityDiagnostics>(); break;
61915 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
61916 case 7: var.destroy<MeNBResourceCoordinationInformation>(); break;
61918 type = 0; ref_nested().clear();
61920 template<typename V> static inline void enumerate(V& v)
61922 v.template operator()<UE_X2AP_ID>(1);
61923 v.template operator()<SgNB_UE_X2AP_ID>(2);
61924 v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConfList>(3);
61925 v.template operator()<MeNBtoSgNBContainer>(4);
61926 v.template operator()<CriticalityDiagnostics>(5);
61927 v.template operator()<UE_X2AP_ID_Extension>(6);
61928 v.template operator()<MeNBResourceCoordinationInformation>(7);
61932 template<typename V> bool decode(size_t index, V& v)
61937 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61938 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61939 case 3: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConfList()); return true;
61940 case 4: v(select_id_MeNBtoSgNBContainer()); return true;
61941 case 5: v(select_id_CriticalityDiagnostics()); return true;
61942 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61943 case 7: v(select_id_MeNBResourceCoordinationInformation()); return true;
61944 case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
61949 template<typename V> bool encode(size_t index, V& v) const
61951 if(index != type) return false;
61954 case 1: v(var.as<UE_X2AP_ID>()); return true;
61955 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61956 case 3: v(var.as<E_RABs_AdmittedToBeModified_SgNBModConfList>()); return true;
61957 case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
61958 case 5: v(var.as<CriticalityDiagnostics>()); return true;
61959 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
61960 case 7: v(var.as<MeNBResourceCoordinationInformation>()); return true;
61966 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61967 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61970 char dummy1[sizeof(CriticalityDiagnostics)];
61971 char dummy2[sizeof(E_RABs_AdmittedToBeModified_SgNBModConfList)];
61972 char dummy3[sizeof(MeNBResourceCoordinationInformation)];
61973 char dummy4[sizeof(MeNBtoSgNBContainer)];
61974 char dummy5[sizeof(SgNB_UE_X2AP_ID)];
61975 char dummy6[sizeof(UE_X2AP_ID)];
61976 char dummy7[sizeof(UE_X2AP_ID_Extension)];
61979 asn::variant<sizeof(union_type)> var;
61983 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61985 size_t get_index() const {return type;}
61986 bool is_unknown() const { return type == 8; }
61987 void clear() {type = 0;}
61988 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61989 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61990 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(optional); type=3;}
61991 void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
61992 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
61993 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
61994 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=7;}
61995 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61996 template<typename V> bool decode(V& v)
61999 if(!v(ref_nested())) return false;
62000 if(equal(mandatory)) { type = 1; return true; }
62001 else if(equal(mandatory)) { type = 2; return true; }
62002 else if(equal(optional)) { type = 3; return true; }
62003 else if(equal(optional)) { type = 4; return true; }
62004 else if(equal(optional)) { type = 5; return true; }
62005 else if(equal(optional)) { type = 6; return true; }
62006 else if(equal(optional)) { type = 7; return true; }
62007 else { type = 8; return true;}
62011 template<typename V> bool encode(V& v) const
62013 return v(ref_nested());
62017 template<typename V> bool decode(size_t index, V& v)
62022 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
62023 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
62024 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
62025 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
62026 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
62027 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
62028 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
62029 case 8: type = 8; return v(ref_nested());
62030 ref_nested().clear();
62035 template<typename V> bool encode(size_t index, V& v) const
62037 if(index != type) {return false;} return v(ref_nested());
62047 SgNBModificationConfirm ::= SEQUENCE {
62048 protocolIEs ProtocolIE-Container {{SgNBModificationConfirm-IEs}},
62053 struct SgNBModificationConfirm : asn::sequence<1, 0, true, 0>
62055 static constexpr const char* name() {return "SgNBModificationConfirm";}
62056 using parent_t = asn::sequence<1, 0, true, 0>;
62057 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationConfirm_IEs>
62059 static constexpr const char* name() {return "protocolIEs_t";}
62060 using parent_t = ProtocolIE_Container<SgNBModificationConfirm_IEs>;
62063 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
62064 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
62065 template<typename V> void decode(V& v)
62070 template<typename V> void encode(V& v) const
62077 protocolIEs.clear();
62081 protocolIEs_t protocolIEs;
62085 SgNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
62086 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
62087 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
62088 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
62089 { ID id-MeNBtoSgNBContainer CRITICALITY ignore TYPE MeNBtoSgNBContainer PRESENCE optional}|
62090 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
62091 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
62096 struct SgNBModificationRefuse_IEs
62098 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
62100 size_t get_index() const {return type;}
62101 bool is_unknown() const { return type == 7; }
62102 void clear() {type = 0;}
62103 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
62104 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
62105 void select_id_Cause() { set(id_Cause); type=3;}
62106 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
62107 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
62108 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
62109 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
62110 template<typename V> bool decode(V& v)
62113 if(!v(ref_nested())) return false;
62114 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
62115 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
62116 else if(equal(id_Cause)) { type = 3; return true; }
62117 else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
62118 else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
62119 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
62120 else { type = 7; return true;}
62124 template<typename V> bool encode(V& v) const
62126 return v(ref_nested());
62130 template<typename V> bool decode(size_t index, V& v)
62135 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
62136 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
62137 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
62138 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
62139 case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
62140 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
62141 case 7: type = 7; return v(ref_nested());
62142 ref_nested().clear();
62147 template<typename V> bool encode(size_t index, V& v) const
62149 if(index != type) {return false;} return v(ref_nested());
62156 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
62158 size_t get_index() const {return type;}
62159 bool is_unknown() const { return type == 7; }
62160 void clear() {type = 0;}
62161 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
62162 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
62163 void select_id_Cause() { set(ignore); type=3;}
62164 void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
62165 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
62166 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
62167 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
62168 template<typename V> bool decode(V& v)
62171 if(!v(ref_nested())) return false;
62172 if(equal(ignore)) { type = 1; return true; }
62173 else if(equal(ignore)) { type = 2; return true; }
62174 else if(equal(ignore)) { type = 3; return true; }
62175 else if(equal(ignore)) { type = 4; return true; }
62176 else if(equal(ignore)) { type = 5; return true; }
62177 else if(equal(ignore)) { type = 6; return true; }
62178 else { type = 7; return true;}
62182 template<typename V> bool encode(V& v) const
62184 return v(ref_nested());
62188 template<typename V> bool decode(size_t index, V& v)
62193 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
62194 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
62195 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
62196 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
62197 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
62198 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
62199 case 7: type = 7; return v(ref_nested());
62200 ref_nested().clear();
62205 template<typename V> bool encode(size_t index, V& v) const
62207 if(index != type) {return false;} return v(ref_nested());
62214 struct Value_t : asn::typefield<true>
62216 ~Value_t() {clear();}
62217 size_t get_index() const {return type;}
62218 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
62219 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
62220 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
62221 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
62222 Cause& select_id_Cause() { return set<Cause>(3); }
62223 Cause const* get_id_Cause() const { return get<Cause>(3); }
62224 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
62225 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
62226 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
62227 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
62228 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
62229 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
62230 bool is_unknown() const { return type == 7; }
62235 case 1: var.destroy<UE_X2AP_ID>(); break;
62236 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
62237 case 3: var.destroy<Cause>(); break;
62238 case 4: var.destroy<MeNBtoSgNBContainer>(); break;
62239 case 5: var.destroy<CriticalityDiagnostics>(); break;
62240 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
62242 type = 0; ref_nested().clear();
62244 template<typename V> static inline void enumerate(V& v)
62246 v.template operator()<UE_X2AP_ID>(1);
62247 v.template operator()<SgNB_UE_X2AP_ID>(2);
62248 v.template operator()<Cause>(3);
62249 v.template operator()<MeNBtoSgNBContainer>(4);
62250 v.template operator()<CriticalityDiagnostics>(5);
62251 v.template operator()<UE_X2AP_ID_Extension>(6);
62255 template<typename V> bool decode(size_t index, V& v)
62260 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
62261 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
62262 case 3: v(select_id_Cause()); return true;
62263 case 4: v(select_id_MeNBtoSgNBContainer()); return true;
62264 case 5: v(select_id_CriticalityDiagnostics()); return true;
62265 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
62266 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
62271 template<typename V> bool encode(size_t index, V& v) const
62273 if(index != type) return false;
62276 case 1: v(var.as<UE_X2AP_ID>()); return true;
62277 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
62278 case 3: v(var.as<Cause>()); return true;
62279 case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
62280 case 5: v(var.as<CriticalityDiagnostics>()); return true;
62281 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
62287 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
62288 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
62291 char dummy1[sizeof(Cause)];
62292 char dummy2[sizeof(CriticalityDiagnostics)];
62293 char dummy3[sizeof(MeNBtoSgNBContainer)];
62294 char dummy4[sizeof(SgNB_UE_X2AP_ID)];
62295 char dummy5[sizeof(UE_X2AP_ID)];
62296 char dummy6[sizeof(UE_X2AP_ID_Extension)];
62299 asn::variant<sizeof(union_type)> var;
62303 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
62305 size_t get_index() const {return type;}
62306 bool is_unknown() const { return type == 7; }
62307 void clear() {type = 0;}
62308 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
62309 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
62310 void select_id_Cause() { set(mandatory); type=3;}
62311 void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
62312 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
62313 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
62314 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
62315 template<typename V> bool decode(V& v)
62318 if(!v(ref_nested())) return false;
62319 if(equal(mandatory)) { type = 1; return true; }
62320 else if(equal(mandatory)) { type = 2; return true; }
62321 else if(equal(mandatory)) { type = 3; return true; }
62322 else if(equal(optional)) { type = 4; return true; }
62323 else if(equal(optional)) { type = 5; return true; }
62324 else if(equal(optional)) { type = 6; return true; }
62325 else { type = 7; return true;}
62329 template<typename V> bool encode(V& v) const
62331 return v(ref_nested());
62335 template<typename V> bool decode(size_t index, V& v)
62340 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
62341 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
62342 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
62343 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
62344 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
62345 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
62346 case 7: type = 7; return v(ref_nested());
62347 ref_nested().clear();
62352 template<typename V> bool encode(size_t index, V& v) const
62354 if(index != type) {return false;} return v(ref_nested());
62364 SgNBModificationRefuse ::= SEQUENCE {
62365 protocolIEs ProtocolIE-Container {{SgNBModificationRefuse-IEs}},
62370 struct SgNBModificationRefuse : asn::sequence<1, 0, true, 0>
62372 static constexpr const char* name() {return "SgNBModificationRefuse";}
62373 using parent_t = asn::sequence<1, 0, true, 0>;
62374 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRefuse_IEs>
62376 static constexpr const char* name() {return "protocolIEs_t";}
62377 using parent_t = ProtocolIE_Container<SgNBModificationRefuse_IEs>;
62380 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
62381 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
62382 template<typename V> void decode(V& v)
62387 template<typename V> void encode(V& v) const
62394 protocolIEs.clear();
62398 protocolIEs_t protocolIEs;
62402 UE-ContextInformationSgNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
62403 { ID id-SubscriberProfileIDforRFP CRITICALITY ignore EXTENSION SubscriberProfileIDforRFP PRESENCE optional},
62408 struct UE_ContextInformationSgNBModReqExtIEs
62410 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
62412 size_t get_index() const {return type;}
62413 bool is_unknown() const { return type == 2; }
62414 void clear() {type = 0;}
62415 void select_id_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); type=1;}
62416 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
62417 template<typename V> bool decode(V& v)
62420 if(!v(ref_nested())) return false;
62421 if(equal(id_SubscriberProfileIDforRFP)) { type = 1; return true; }
62422 else { type = 2; return true;}
62426 template<typename V> bool encode(V& v) const
62428 return v(ref_nested());
62432 template<typename V> bool decode(size_t index, V& v)
62437 case 1: type = 1; if(v(ref_nested())) { return equal(id_SubscriberProfileIDforRFP);} return false;
62438 case 2: type = 2; return v(ref_nested());
62439 ref_nested().clear();
62444 template<typename V> bool encode(size_t index, V& v) const
62446 if(index != type) {return false;} return v(ref_nested());
62453 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
62455 size_t get_index() const {return type;}
62456 bool is_unknown() const { return type == 2; }
62457 void clear() {type = 0;}
62458 void select_id_SubscriberProfileIDforRFP() { set(ignore); type=1;}
62459 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
62460 template<typename V> bool decode(V& v)
62463 if(!v(ref_nested())) return false;
62464 if(equal(ignore)) { type = 1; return true; }
62465 else { type = 2; return true;}
62469 template<typename V> bool encode(V& v) const
62471 return v(ref_nested());
62475 template<typename V> bool decode(size_t index, V& v)
62480 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
62481 case 2: type = 2; return v(ref_nested());
62482 ref_nested().clear();
62487 template<typename V> bool encode(size_t index, V& v) const
62489 if(index != type) {return false;} return v(ref_nested());
62496 struct Extension_t : asn::typefield<true>
62498 ~Extension_t() {clear();}
62499 size_t get_index() const {return type;}
62500 SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(1); }
62501 SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(1); }
62502 bool is_unknown() const { return type == 2; }
62507 case 1: var.destroy<SubscriberProfileIDforRFP>(); break;
62509 type = 0; ref_nested().clear();
62511 template<typename V> static inline void enumerate(V& v)
62513 v.template operator()<SubscriberProfileIDforRFP>(1);
62517 template<typename V> bool decode(size_t index, V& v)
62522 case 1: v(select_id_SubscriberProfileIDforRFP()); return true;
62523 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
62528 template<typename V> bool encode(size_t index, V& v) const
62530 if(index != type) return false;
62533 case 1: v(var.as<SubscriberProfileIDforRFP>()); return true;
62539 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
62540 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
62543 char dummy1[sizeof(SubscriberProfileIDforRFP)];
62546 asn::variant<sizeof(union_type)> var;
62550 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
62552 size_t get_index() const {return type;}
62553 bool is_unknown() const { return type == 2; }
62554 void clear() {type = 0;}
62555 void select_id_SubscriberProfileIDforRFP() { set(optional); type=1;}
62556 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
62557 template<typename V> bool decode(V& v)
62560 if(!v(ref_nested())) return false;
62561 if(equal(optional)) { type = 1; return true; }
62562 else { type = 2; return true;}
62566 template<typename V> bool encode(V& v) const
62568 return v(ref_nested());
62572 template<typename V> bool decode(size_t index, V& v)
62577 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
62578 case 2: type = 2; return v(ref_nested());
62579 ref_nested().clear();
62584 template<typename V> bool encode(size_t index, V& v) const
62586 if(index != type) {return false;} return v(ref_nested());
62596 UE-ContextInformation-SgNBModReq ::= SEQUENCE {
62597 nRUE-SecurityCapabilities NRUESecurityCapabilities OPTIONAL,
62598 sgNB-SecurityKey SgNBSecurityKey OPTIONAL,
62599 sgNBUEAggregateMaximumBitRate UEAggregateMaximumBitRate OPTIONAL,
62600 e-RABs-ToBeAdded E-RABs-ToBeAdded-SgNBModReq-List OPTIONAL,
62601 e-RABs-ToBeModified E-RABs-ToBeModified-SgNBModReq-List OPTIONAL,
62602 e-RABs-ToBeReleased E-RABs-ToBeReleased-SgNBModReq-List OPTIONAL,
62603 iE-Extensions ProtocolExtensionContainer { {UE-ContextInformationSgNBModReqExtIEs} } OPTIONAL,
62608 struct UE_ContextInformation_SgNBModReq : asn::sequence<7, 0, true, 7>
62610 static constexpr const char* name() {return "UE-ContextInformation-SgNBModReq";}
62611 using parent_t = asn::sequence<7, 0, true, 7>;
62612 struct nRUE_SecurityCapabilities_t : NRUESecurityCapabilities
62614 static constexpr const char* name() {return "nRUE_SecurityCapabilities_t";}
62615 using parent_t = NRUESecurityCapabilities;
62616 static constexpr bool optional = true;
62619 nRUE_SecurityCapabilities_t& set_nRUE_SecurityCapabilities() { nRUE_SecurityCapabilities.setpresent(true); return nRUE_SecurityCapabilities;}
62620 nRUE_SecurityCapabilities_t const* get_nRUE_SecurityCapabilities() const {return nRUE_SecurityCapabilities.is_valid() ? &nRUE_SecurityCapabilities : nullptr;}
62621 struct sgNB_SecurityKey_t : SgNBSecurityKey
62623 static constexpr const char* name() {return "sgNB_SecurityKey_t";}
62624 using parent_t = SgNBSecurityKey;
62625 static constexpr bool optional = true;
62628 sgNB_SecurityKey_t& set_sgNB_SecurityKey() { sgNB_SecurityKey.setpresent(true); return sgNB_SecurityKey;}
62629 sgNB_SecurityKey_t const* get_sgNB_SecurityKey() const {return sgNB_SecurityKey.is_valid() ? &sgNB_SecurityKey : nullptr;}
62630 struct sgNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
62632 static constexpr const char* name() {return "sgNBUEAggregateMaximumBitRate_t";}
62633 using parent_t = UEAggregateMaximumBitRate;
62634 static constexpr bool optional = true;
62637 sgNBUEAggregateMaximumBitRate_t& set_sgNBUEAggregateMaximumBitRate() { sgNBUEAggregateMaximumBitRate.setpresent(true); return sgNBUEAggregateMaximumBitRate;}
62638 sgNBUEAggregateMaximumBitRate_t const* get_sgNBUEAggregateMaximumBitRate() const {return sgNBUEAggregateMaximumBitRate.is_valid() ? &sgNBUEAggregateMaximumBitRate : nullptr;}
62639 struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_SgNBModReq_List
62641 static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
62642 using parent_t = E_RABs_ToBeAdded_SgNBModReq_List;
62643 static constexpr bool optional = true;
62646 e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
62647 e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
62648 struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_SgNBModReq_List
62650 static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
62651 using parent_t = E_RABs_ToBeModified_SgNBModReq_List;
62652 static constexpr bool optional = true;
62655 e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
62656 e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
62657 struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_SgNBModReq_List
62659 static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
62660 using parent_t = E_RABs_ToBeReleased_SgNBModReq_List;
62661 static constexpr bool optional = true;
62664 e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
62665 e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
62666 struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>
62668 static constexpr const char* name() {return "iE_Extensions_t";}
62669 using parent_t = ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>;
62670 static constexpr bool optional = true;
62673 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
62674 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
62675 template<typename V> void decode(V& v)
62677 v(nRUE_SecurityCapabilities);
62678 v(sgNB_SecurityKey);
62679 v(sgNBUEAggregateMaximumBitRate);
62680 v(e_RABs_ToBeAdded);
62681 v(e_RABs_ToBeModified);
62682 v(e_RABs_ToBeReleased);
62686 template<typename V> void encode(V& v) const
62688 v(nRUE_SecurityCapabilities);
62689 v(sgNB_SecurityKey);
62690 v(sgNBUEAggregateMaximumBitRate);
62691 v(e_RABs_ToBeAdded);
62692 v(e_RABs_ToBeModified);
62693 v(e_RABs_ToBeReleased);
62699 nRUE_SecurityCapabilities.clear();
62700 sgNB_SecurityKey.clear();
62701 sgNBUEAggregateMaximumBitRate.clear();
62702 e_RABs_ToBeAdded.clear();
62703 e_RABs_ToBeModified.clear();
62704 e_RABs_ToBeReleased.clear();
62705 iE_Extensions.clear();
62709 nRUE_SecurityCapabilities_t nRUE_SecurityCapabilities;
62710 sgNB_SecurityKey_t sgNB_SecurityKey;
62711 sgNBUEAggregateMaximumBitRate_t sgNBUEAggregateMaximumBitRate;
62712 e_RABs_ToBeAdded_t e_RABs_ToBeAdded;
62713 e_RABs_ToBeModified_t e_RABs_ToBeModified;
62714 e_RABs_ToBeReleased_t e_RABs_ToBeReleased;
62715 iE_Extensions_t iE_Extensions;
62719 SgNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
62720 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
62721 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
62722 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
62723 { ID id-SelectedPLMN CRITICALITY ignore TYPE PLMN-Identity PRESENCE optional}|
62724 { ID id-HandoverRestrictionList CRITICALITY ignore TYPE HandoverRestrictionList PRESENCE optional}|
62725 { ID id-SCGConfigurationQuery CRITICALITY ignore TYPE SCGConfigurationQuery PRESENCE optional}|
62726 { ID id-UE-ContextInformation-SgNBModReq CRITICALITY reject TYPE UE-ContextInformation-SgNBModReq PRESENCE optional}|
62727 { ID id-MeNBtoSgNBContainer CRITICALITY reject TYPE MeNBtoSgNBContainer PRESENCE optional}|
62728 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
62729 { ID id-MeNBResourceCoordinationInformation CRITICALITY ignore TYPE MeNBResourceCoordinationInformation PRESENCE optional}|
62730 { ID id-RequestedSplitSRBs CRITICALITY ignore TYPE SplitSRBs PRESENCE optional}|
62731 { ID id-RequestedSplitSRBsrelease CRITICALITY ignore TYPE SplitSRBs PRESENCE optional},
62736 struct SgNBModificationRequest_IEs
62738 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
62740 size_t get_index() const {return type;}
62741 bool is_unknown() const { return type == 13; }
62742 void clear() {type = 0;}
62743 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
62744 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
62745 void select_id_Cause() { set(id_Cause); type=3;}
62746 void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=4;}
62747 void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=5;}
62748 void select_id_SCGConfigurationQuery() { set(id_SCGConfigurationQuery); type=6;}
62749 void select_id_UE_ContextInformation_SgNBModReq() { set(id_UE_ContextInformation_SgNBModReq); type=7;}
62750 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
62751 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
62752 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=10;}
62753 void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=11;}
62754 void select_id_RequestedSplitSRBsrelease() { set(id_RequestedSplitSRBsrelease); type=12;}
62755 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
62756 template<typename V> bool decode(V& v)
62759 if(!v(ref_nested())) return false;
62760 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
62761 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
62762 else if(equal(id_Cause)) { type = 3; return true; }
62763 else if(equal(id_SelectedPLMN)) { type = 4; return true; }
62764 else if(equal(id_HandoverRestrictionList)) { type = 5; return true; }
62765 else if(equal(id_SCGConfigurationQuery)) { type = 6; return true; }
62766 else if(equal(id_UE_ContextInformation_SgNBModReq)) { type = 7; return true; }
62767 else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
62768 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
62769 else if(equal(id_MeNBResourceCoordinationInformation)) { type = 10; return true; }
62770 else if(equal(id_RequestedSplitSRBs)) { type = 11; return true; }
62771 else if(equal(id_RequestedSplitSRBsrelease)) { type = 12; return true; }
62772 else { type = 13; return true;}
62776 template<typename V> bool encode(V& v) const
62778 return v(ref_nested());
62782 template<typename V> bool decode(size_t index, V& v)
62787 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
62788 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
62789 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
62790 case 4: type = 4; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
62791 case 5: type = 5; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
62792 case 6: type = 6; if(v(ref_nested())) { return equal(id_SCGConfigurationQuery);} return false;
62793 case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextInformation_SgNBModReq);} return false;
62794 case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
62795 case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
62796 case 10: type = 10; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
62797 case 11: type = 11; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
62798 case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBsrelease);} return false;
62799 case 13: type = 13; return v(ref_nested());
62800 ref_nested().clear();
62805 template<typename V> bool encode(size_t index, V& v) const
62807 if(index != type) {return false;} return v(ref_nested());
62814 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
62816 size_t get_index() const {return type;}
62817 bool is_unknown() const { return type == 13; }
62818 void clear() {type = 0;}
62819 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
62820 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
62821 void select_id_Cause() { set(ignore); type=3;}
62822 void select_id_SelectedPLMN() { set(ignore); type=4;}
62823 void select_id_HandoverRestrictionList() { set(ignore); type=5;}
62824 void select_id_SCGConfigurationQuery() { set(ignore); type=6;}
62825 void select_id_UE_ContextInformation_SgNBModReq() { set(reject); type=7;}
62826 void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
62827 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
62828 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=10;}
62829 void select_id_RequestedSplitSRBs() { set(ignore); type=11;}
62830 void select_id_RequestedSplitSRBsrelease() { set(ignore); type=12;}
62831 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
62832 template<typename V> bool decode(V& v)
62835 if(!v(ref_nested())) return false;
62836 if(equal(reject)) { type = 1; return true; }
62837 else if(equal(reject)) { type = 2; return true; }
62838 else if(equal(ignore)) { type = 3; return true; }
62839 else if(equal(ignore)) { type = 4; return true; }
62840 else if(equal(ignore)) { type = 5; return true; }
62841 else if(equal(ignore)) { type = 6; return true; }
62842 else if(equal(reject)) { type = 7; return true; }
62843 else if(equal(reject)) { type = 8; return true; }
62844 else if(equal(reject)) { type = 9; return true; }
62845 else if(equal(ignore)) { type = 10; return true; }
62846 else if(equal(ignore)) { type = 11; return true; }
62847 else if(equal(ignore)) { type = 12; return true; }
62848 else { type = 13; return true;}
62852 template<typename V> bool encode(V& v) const
62854 return v(ref_nested());
62858 template<typename V> bool decode(size_t index, V& v)
62863 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
62864 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
62865 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
62866 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
62867 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
62868 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
62869 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
62870 case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
62871 case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
62872 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
62873 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
62874 case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
62875 case 13: type = 13; return v(ref_nested());
62876 ref_nested().clear();
62881 template<typename V> bool encode(size_t index, V& v) const
62883 if(index != type) {return false;} return v(ref_nested());
62890 struct Value_t : asn::typefield<true>
62892 ~Value_t() {clear();}
62893 size_t get_index() const {return type;}
62894 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
62895 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
62896 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
62897 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
62898 Cause& select_id_Cause() { return set<Cause>(3); }
62899 Cause const* get_id_Cause() const { return get<Cause>(3); }
62900 PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(4); }
62901 PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(4); }
62902 HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(5); }
62903 HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(5); }
62904 SCGConfigurationQuery& select_id_SCGConfigurationQuery() { return set<SCGConfigurationQuery>(6); }
62905 SCGConfigurationQuery const* get_id_SCGConfigurationQuery() const { return get<SCGConfigurationQuery>(6); }
62906 UE_ContextInformation_SgNBModReq& select_id_UE_ContextInformation_SgNBModReq() { return set<UE_ContextInformation_SgNBModReq>(7); }
62907 UE_ContextInformation_SgNBModReq const* get_id_UE_ContextInformation_SgNBModReq() const { return get<UE_ContextInformation_SgNBModReq>(7); }
62908 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
62909 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
62910 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
62911 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
62912 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(10); }
62913 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(10); }
62914 SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(11); }
62915 SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(11); }
62916 SplitSRBs& select_id_RequestedSplitSRBsrelease() { return set<SplitSRBs>(12); }
62917 SplitSRBs const* get_id_RequestedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
62918 bool is_unknown() const { return type == 13; }
62923 case 1: var.destroy<UE_X2AP_ID>(); break;
62924 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
62925 case 3: var.destroy<Cause>(); break;
62926 case 4: var.destroy<PLMN_Identity>(); break;
62927 case 5: var.destroy<HandoverRestrictionList>(); break;
62928 case 6: var.destroy<SCGConfigurationQuery>(); break;
62929 case 7: var.destroy<UE_ContextInformation_SgNBModReq>(); break;
62930 case 8: var.destroy<MeNBtoSgNBContainer>(); break;
62931 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
62932 case 10: var.destroy<MeNBResourceCoordinationInformation>(); break;
62933 case 11: var.destroy<SplitSRBs>(); break;
62934 case 12: var.destroy<SplitSRBs>(); break;
62936 type = 0; ref_nested().clear();
62938 template<typename V> static inline void enumerate(V& v)
62940 v.template operator()<UE_X2AP_ID>(1);
62941 v.template operator()<SgNB_UE_X2AP_ID>(2);
62942 v.template operator()<Cause>(3);
62943 v.template operator()<PLMN_Identity>(4);
62944 v.template operator()<HandoverRestrictionList>(5);
62945 v.template operator()<SCGConfigurationQuery>(6);
62946 v.template operator()<UE_ContextInformation_SgNBModReq>(7);
62947 v.template operator()<MeNBtoSgNBContainer>(8);
62948 v.template operator()<UE_X2AP_ID_Extension>(9);
62949 v.template operator()<MeNBResourceCoordinationInformation>(10);
62950 v.template operator()<SplitSRBs>(11);
62951 v.template operator()<SplitSRBs>(12);
62955 template<typename V> bool decode(size_t index, V& v)
62960 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
62961 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
62962 case 3: v(select_id_Cause()); return true;
62963 case 4: v(select_id_SelectedPLMN()); return true;
62964 case 5: v(select_id_HandoverRestrictionList()); return true;
62965 case 6: v(select_id_SCGConfigurationQuery()); return true;
62966 case 7: v(select_id_UE_ContextInformation_SgNBModReq()); return true;
62967 case 8: v(select_id_MeNBtoSgNBContainer()); return true;
62968 case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
62969 case 10: v(select_id_MeNBResourceCoordinationInformation()); return true;
62970 case 11: v(select_id_RequestedSplitSRBs()); return true;
62971 case 12: v(select_id_RequestedSplitSRBsrelease()); return true;
62972 case 13: if(type != 13) {clear(); asn::base::set();} type = 13; return true;
62977 template<typename V> bool encode(size_t index, V& v) const
62979 if(index != type) return false;
62982 case 1: v(var.as<UE_X2AP_ID>()); return true;
62983 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
62984 case 3: v(var.as<Cause>()); return true;
62985 case 4: v(var.as<PLMN_Identity>()); return true;
62986 case 5: v(var.as<HandoverRestrictionList>()); return true;
62987 case 6: v(var.as<SCGConfigurationQuery>()); return true;
62988 case 7: v(var.as<UE_ContextInformation_SgNBModReq>()); return true;
62989 case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
62990 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
62991 case 10: v(var.as<MeNBResourceCoordinationInformation>()); return true;
62992 case 11: v(var.as<SplitSRBs>()); return true;
62993 case 12: v(var.as<SplitSRBs>()); return true;
62999 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63000 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63003 char dummy1[sizeof(Cause)];
63004 char dummy2[sizeof(HandoverRestrictionList)];
63005 char dummy3[sizeof(MeNBResourceCoordinationInformation)];
63006 char dummy4[sizeof(MeNBtoSgNBContainer)];
63007 char dummy5[sizeof(PLMN_Identity)];
63008 char dummy6[sizeof(SCGConfigurationQuery)];
63009 char dummy7[sizeof(SgNB_UE_X2AP_ID)];
63010 char dummy8[sizeof(SplitSRBs)];
63011 char dummy9[sizeof(UE_ContextInformation_SgNBModReq)];
63012 char dummy10[sizeof(UE_X2AP_ID)];
63013 char dummy11[sizeof(UE_X2AP_ID_Extension)];
63016 asn::variant<sizeof(union_type)> var;
63020 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63022 size_t get_index() const {return type;}
63023 bool is_unknown() const { return type == 13; }
63024 void clear() {type = 0;}
63025 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63026 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63027 void select_id_Cause() { set(mandatory); type=3;}
63028 void select_id_SelectedPLMN() { set(optional); type=4;}
63029 void select_id_HandoverRestrictionList() { set(optional); type=5;}
63030 void select_id_SCGConfigurationQuery() { set(optional); type=6;}
63031 void select_id_UE_ContextInformation_SgNBModReq() { set(optional); type=7;}
63032 void select_id_MeNBtoSgNBContainer() { set(optional); type=8;}
63033 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
63034 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=10;}
63035 void select_id_RequestedSplitSRBs() { set(optional); type=11;}
63036 void select_id_RequestedSplitSRBsrelease() { set(optional); type=12;}
63037 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63038 template<typename V> bool decode(V& v)
63041 if(!v(ref_nested())) return false;
63042 if(equal(mandatory)) { type = 1; return true; }
63043 else if(equal(mandatory)) { type = 2; return true; }
63044 else if(equal(mandatory)) { type = 3; return true; }
63045 else if(equal(optional)) { type = 4; return true; }
63046 else if(equal(optional)) { type = 5; return true; }
63047 else if(equal(optional)) { type = 6; return true; }
63048 else if(equal(optional)) { type = 7; return true; }
63049 else if(equal(optional)) { type = 8; return true; }
63050 else if(equal(optional)) { type = 9; return true; }
63051 else if(equal(optional)) { type = 10; return true; }
63052 else if(equal(optional)) { type = 11; return true; }
63053 else if(equal(optional)) { type = 12; return true; }
63054 else { type = 13; return true;}
63058 template<typename V> bool encode(V& v) const
63060 return v(ref_nested());
63064 template<typename V> bool decode(size_t index, V& v)
63069 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63070 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63071 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
63072 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63073 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63074 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
63075 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
63076 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
63077 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
63078 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
63079 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
63080 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
63081 case 13: type = 13; return v(ref_nested());
63082 ref_nested().clear();
63087 template<typename V> bool encode(size_t index, V& v) const
63089 if(index != type) {return false;} return v(ref_nested());
63099 SgNBModificationRequest ::= SEQUENCE {
63100 protocolIEs ProtocolIE-Container {{ SgNBModificationRequest-IEs}},
63105 struct SgNBModificationRequest : asn::sequence<1, 0, true, 0>
63107 static constexpr const char* name() {return "SgNBModificationRequest";}
63108 using parent_t = asn::sequence<1, 0, true, 0>;
63109 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequest_IEs>
63111 static constexpr const char* name() {return "protocolIEs_t";}
63112 using parent_t = ProtocolIE_Container<SgNBModificationRequest_IEs>;
63115 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63116 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63117 template<typename V> void decode(V& v)
63122 template<typename V> void encode(V& v) const
63129 protocolIEs.clear();
63133 protocolIEs_t protocolIEs;
63137 SgNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
63138 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
63139 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
63140 { ID id-E-RABs-Admitted-ToBeAdded-SgNBModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeAdded-SgNBModAckList PRESENCE optional}|
63141 { ID id-E-RABs-Admitted-ToBeModified-SgNBModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeModified-SgNBModAckList PRESENCE optional}|
63142 { ID id-E-RABs-Admitted-ToBeReleased-SgNBModAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeReleased-SgNBModAckList PRESENCE optional}|
63143 { ID id-E-RABs-NotAdmitted-List CRITICALITY ignore TYPE E-RAB-List PRESENCE optional}|
63144 { ID id-SgNBtoMeNBContainer CRITICALITY ignore TYPE SgNBtoMeNBContainer PRESENCE optional}|
63145 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
63146 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional}|
63147 { ID id-SgNBResourceCoordinationInformation CRITICALITY ignore TYPE SgNBResourceCoordinationInformation PRESENCE optional}|
63148 { ID id-AdmittedSplitSRBs CRITICALITY ignore TYPE SplitSRBs PRESENCE optional}|
63149 { ID id-AdmittedSplitSRBsrelease CRITICALITY ignore TYPE SplitSRBs PRESENCE optional}|
63150 { ID id-RRCConfigIndication CRITICALITY reject TYPE RRC-Config-Ind PRESENCE optional},
63155 struct SgNBModificationRequestAcknowledge_IEs
63157 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63159 size_t get_index() const {return type;}
63160 bool is_unknown() const { return type == 14; }
63161 void clear() {type = 0;}
63162 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63163 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63164 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList); type=3;}
63165 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAckList); type=4;}
63166 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList); type=5;}
63167 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
63168 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=7;}
63169 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
63170 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
63171 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=10;}
63172 void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=11;}
63173 void select_id_AdmittedSplitSRBsrelease() { set(id_AdmittedSplitSRBsrelease); type=12;}
63174 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=13;}
63175 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63176 template<typename V> bool decode(V& v)
63179 if(!v(ref_nested())) return false;
63180 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63181 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63182 else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList)) { type = 3; return true; }
63183 else if(equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList)) { type = 4; return true; }
63184 else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList)) { type = 5; return true; }
63185 else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
63186 else if(equal(id_SgNBtoMeNBContainer)) { type = 7; return true; }
63187 else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
63188 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
63189 else if(equal(id_SgNBResourceCoordinationInformation)) { type = 10; return true; }
63190 else if(equal(id_AdmittedSplitSRBs)) { type = 11; return true; }
63191 else if(equal(id_AdmittedSplitSRBsrelease)) { type = 12; return true; }
63192 else if(equal(id_RRCConfigIndication)) { type = 13; return true; }
63193 else { type = 14; return true;}
63197 template<typename V> bool encode(V& v) const
63199 return v(ref_nested());
63203 template<typename V> bool decode(size_t index, V& v)
63208 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63209 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63210 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList);} return false;
63211 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList);} return false;
63212 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList);} return false;
63213 case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
63214 case 7: type = 7; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
63215 case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
63216 case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63217 case 10: type = 10; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
63218 case 11: type = 11; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
63219 case 12: type = 12; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBsrelease);} return false;
63220 case 13: type = 13; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
63221 case 14: type = 14; return v(ref_nested());
63222 ref_nested().clear();
63227 template<typename V> bool encode(size_t index, V& v) const
63229 if(index != type) {return false;} return v(ref_nested());
63236 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63238 size_t get_index() const {return type;}
63239 bool is_unknown() const { return type == 14; }
63240 void clear() {type = 0;}
63241 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
63242 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
63243 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(ignore); type=3;}
63244 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(ignore); type=4;}
63245 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(ignore); type=5;}
63246 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
63247 void select_id_SgNBtoMeNBContainer() { set(ignore); type=7;}
63248 void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
63249 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
63250 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=10;}
63251 void select_id_AdmittedSplitSRBs() { set(ignore); type=11;}
63252 void select_id_AdmittedSplitSRBsrelease() { set(ignore); type=12;}
63253 void select_id_RRCConfigIndication() { set(reject); type=13;}
63254 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63255 template<typename V> bool decode(V& v)
63258 if(!v(ref_nested())) return false;
63259 if(equal(ignore)) { type = 1; return true; }
63260 else if(equal(ignore)) { type = 2; return true; }
63261 else if(equal(ignore)) { type = 3; return true; }
63262 else if(equal(ignore)) { type = 4; return true; }
63263 else if(equal(ignore)) { type = 5; return true; }
63264 else if(equal(ignore)) { type = 6; return true; }
63265 else if(equal(ignore)) { type = 7; return true; }
63266 else if(equal(ignore)) { type = 8; return true; }
63267 else if(equal(ignore)) { type = 9; return true; }
63268 else if(equal(ignore)) { type = 10; return true; }
63269 else if(equal(ignore)) { type = 11; return true; }
63270 else if(equal(ignore)) { type = 12; return true; }
63271 else if(equal(reject)) { type = 13; return true; }
63272 else { type = 14; return true;}
63276 template<typename V> bool encode(V& v) const
63278 return v(ref_nested());
63282 template<typename V> bool decode(size_t index, V& v)
63287 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
63288 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
63289 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
63290 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
63291 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
63292 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
63293 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
63294 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
63295 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
63296 case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
63297 case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
63298 case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
63299 case 13: type = 13; if(v(ref_nested())) { return equal(reject);} return false;
63300 case 14: type = 14; return v(ref_nested());
63301 ref_nested().clear();
63306 template<typename V> bool encode(size_t index, V& v) const
63308 if(index != type) {return false;} return v(ref_nested());
63315 struct Value_t : asn::typefield<true>
63317 ~Value_t() {clear();}
63318 size_t get_index() const {return type;}
63319 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
63320 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
63321 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
63322 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
63323 E_RABs_Admitted_ToBeAdded_SgNBModAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
63324 E_RABs_Admitted_ToBeAdded_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
63325 E_RABs_Admitted_ToBeModified_SgNBModAckList& select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { return set<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
63326 E_RABs_Admitted_ToBeModified_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
63327 E_RABs_Admitted_ToBeReleased_SgNBModAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
63328 E_RABs_Admitted_ToBeReleased_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
63329 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
63330 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
63331 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(7); }
63332 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(7); }
63333 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
63334 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
63335 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
63336 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
63337 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(10); }
63338 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(10); }
63339 SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(11); }
63340 SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(11); }
63341 SplitSRBs& select_id_AdmittedSplitSRBsrelease() { return set<SplitSRBs>(12); }
63342 SplitSRBs const* get_id_AdmittedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
63343 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(13); }
63344 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(13); }
63345 bool is_unknown() const { return type == 14; }
63350 case 1: var.destroy<UE_X2AP_ID>(); break;
63351 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
63352 case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(); break;
63353 case 4: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAckList>(); break;
63354 case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(); break;
63355 case 6: var.destroy<E_RAB_List>(); break;
63356 case 7: var.destroy<SgNBtoMeNBContainer>(); break;
63357 case 8: var.destroy<CriticalityDiagnostics>(); break;
63358 case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
63359 case 10: var.destroy<SgNBResourceCoordinationInformation>(); break;
63360 case 11: var.destroy<SplitSRBs>(); break;
63361 case 12: var.destroy<SplitSRBs>(); break;
63362 case 13: var.destroy<RRC_Config_Ind>(); break;
63364 type = 0; ref_nested().clear();
63366 template<typename V> static inline void enumerate(V& v)
63368 v.template operator()<UE_X2AP_ID>(1);
63369 v.template operator()<SgNB_UE_X2AP_ID>(2);
63370 v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3);
63371 v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4);
63372 v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5);
63373 v.template operator()<E_RAB_List>(6);
63374 v.template operator()<SgNBtoMeNBContainer>(7);
63375 v.template operator()<CriticalityDiagnostics>(8);
63376 v.template operator()<UE_X2AP_ID_Extension>(9);
63377 v.template operator()<SgNBResourceCoordinationInformation>(10);
63378 v.template operator()<SplitSRBs>(11);
63379 v.template operator()<SplitSRBs>(12);
63380 v.template operator()<RRC_Config_Ind>(13);
63384 template<typename V> bool decode(size_t index, V& v)
63389 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
63390 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
63391 case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList()); return true;
63392 case 4: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList()); return true;
63393 case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList()); return true;
63394 case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
63395 case 7: v(select_id_SgNBtoMeNBContainer()); return true;
63396 case 8: v(select_id_CriticalityDiagnostics()); return true;
63397 case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
63398 case 10: v(select_id_SgNBResourceCoordinationInformation()); return true;
63399 case 11: v(select_id_AdmittedSplitSRBs()); return true;
63400 case 12: v(select_id_AdmittedSplitSRBsrelease()); return true;
63401 case 13: v(select_id_RRCConfigIndication()); return true;
63402 case 14: if(type != 14) {clear(); asn::base::set();} type = 14; return true;
63407 template<typename V> bool encode(size_t index, V& v) const
63409 if(index != type) return false;
63412 case 1: v(var.as<UE_X2AP_ID>()); return true;
63413 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
63414 case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBModAckList>()); return true;
63415 case 4: v(var.as<E_RABs_Admitted_ToBeModified_SgNBModAckList>()); return true;
63416 case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBModAckList>()); return true;
63417 case 6: v(var.as<E_RAB_List>()); return true;
63418 case 7: v(var.as<SgNBtoMeNBContainer>()); return true;
63419 case 8: v(var.as<CriticalityDiagnostics>()); return true;
63420 case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
63421 case 10: v(var.as<SgNBResourceCoordinationInformation>()); return true;
63422 case 11: v(var.as<SplitSRBs>()); return true;
63423 case 12: v(var.as<SplitSRBs>()); return true;
63424 case 13: v(var.as<RRC_Config_Ind>()); return true;
63430 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63431 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63434 char dummy1[sizeof(CriticalityDiagnostics)];
63435 char dummy2[sizeof(E_RAB_List)];
63436 char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBModAckList)];
63437 char dummy4[sizeof(E_RABs_Admitted_ToBeModified_SgNBModAckList)];
63438 char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_SgNBModAckList)];
63439 char dummy6[sizeof(RRC_Config_Ind)];
63440 char dummy7[sizeof(SgNBResourceCoordinationInformation)];
63441 char dummy8[sizeof(SgNB_UE_X2AP_ID)];
63442 char dummy9[sizeof(SgNBtoMeNBContainer)];
63443 char dummy10[sizeof(SplitSRBs)];
63444 char dummy11[sizeof(UE_X2AP_ID)];
63445 char dummy12[sizeof(UE_X2AP_ID_Extension)];
63448 asn::variant<sizeof(union_type)> var;
63452 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63454 size_t get_index() const {return type;}
63455 bool is_unknown() const { return type == 14; }
63456 void clear() {type = 0;}
63457 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63458 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63459 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(optional); type=3;}
63460 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(optional); type=4;}
63461 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(optional); type=5;}
63462 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
63463 void select_id_SgNBtoMeNBContainer() { set(optional); type=7;}
63464 void select_id_CriticalityDiagnostics() { set(optional); type=8;}
63465 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
63466 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=10;}
63467 void select_id_AdmittedSplitSRBs() { set(optional); type=11;}
63468 void select_id_AdmittedSplitSRBsrelease() { set(optional); type=12;}
63469 void select_id_RRCConfigIndication() { set(optional); type=13;}
63470 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63471 template<typename V> bool decode(V& v)
63474 if(!v(ref_nested())) return false;
63475 if(equal(mandatory)) { type = 1; return true; }
63476 else if(equal(mandatory)) { type = 2; return true; }
63477 else if(equal(optional)) { type = 3; return true; }
63478 else if(equal(optional)) { type = 4; return true; }
63479 else if(equal(optional)) { type = 5; return true; }
63480 else if(equal(optional)) { type = 6; return true; }
63481 else if(equal(optional)) { type = 7; return true; }
63482 else if(equal(optional)) { type = 8; return true; }
63483 else if(equal(optional)) { type = 9; return true; }
63484 else if(equal(optional)) { type = 10; return true; }
63485 else if(equal(optional)) { type = 11; return true; }
63486 else if(equal(optional)) { type = 12; return true; }
63487 else if(equal(optional)) { type = 13; return true; }
63488 else { type = 14; return true;}
63492 template<typename V> bool encode(V& v) const
63494 return v(ref_nested());
63498 template<typename V> bool decode(size_t index, V& v)
63503 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63504 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63505 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
63506 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63507 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63508 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
63509 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
63510 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
63511 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
63512 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
63513 case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
63514 case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
63515 case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
63516 case 14: type = 14; return v(ref_nested());
63517 ref_nested().clear();
63522 template<typename V> bool encode(size_t index, V& v) const
63524 if(index != type) {return false;} return v(ref_nested());
63534 SgNBModificationRequestAcknowledge ::= SEQUENCE {
63535 protocolIEs ProtocolIE-Container {{SgNBModificationRequestAcknowledge-IEs}},
63540 struct SgNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
63542 static constexpr const char* name() {return "SgNBModificationRequestAcknowledge";}
63543 using parent_t = asn::sequence<1, 0, true, 0>;
63544 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>
63546 static constexpr const char* name() {return "protocolIEs_t";}
63547 using parent_t = ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>;
63550 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63551 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63552 template<typename V> void decode(V& v)
63557 template<typename V> void encode(V& v) const
63564 protocolIEs.clear();
63568 protocolIEs_t protocolIEs;
63572 SgNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
63573 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
63574 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
63575 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
63576 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
63577 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
63582 struct SgNBModificationRequestReject_IEs
63584 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63586 size_t get_index() const {return type;}
63587 bool is_unknown() const { return type == 6; }
63588 void clear() {type = 0;}
63589 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63590 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63591 void select_id_Cause() { set(id_Cause); type=3;}
63592 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
63593 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
63594 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63595 template<typename V> bool decode(V& v)
63598 if(!v(ref_nested())) return false;
63599 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63600 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63601 else if(equal(id_Cause)) { type = 3; return true; }
63602 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
63603 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
63604 else { type = 6; return true;}
63608 template<typename V> bool encode(V& v) const
63610 return v(ref_nested());
63614 template<typename V> bool decode(size_t index, V& v)
63619 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63620 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63621 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
63622 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
63623 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63624 case 6: type = 6; return v(ref_nested());
63625 ref_nested().clear();
63630 template<typename V> bool encode(size_t index, V& v) const
63632 if(index != type) {return false;} return v(ref_nested());
63639 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63641 size_t get_index() const {return type;}
63642 bool is_unknown() const { return type == 6; }
63643 void clear() {type = 0;}
63644 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
63645 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
63646 void select_id_Cause() { set(ignore); type=3;}
63647 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
63648 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
63649 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63650 template<typename V> bool decode(V& v)
63653 if(!v(ref_nested())) return false;
63654 if(equal(ignore)) { type = 1; return true; }
63655 else if(equal(ignore)) { type = 2; return true; }
63656 else if(equal(ignore)) { type = 3; return true; }
63657 else if(equal(ignore)) { type = 4; return true; }
63658 else if(equal(ignore)) { type = 5; return true; }
63659 else { type = 6; return true;}
63663 template<typename V> bool encode(V& v) const
63665 return v(ref_nested());
63669 template<typename V> bool decode(size_t index, V& v)
63674 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
63675 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
63676 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
63677 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
63678 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
63679 case 6: type = 6; return v(ref_nested());
63680 ref_nested().clear();
63685 template<typename V> bool encode(size_t index, V& v) const
63687 if(index != type) {return false;} return v(ref_nested());
63694 struct Value_t : asn::typefield<true>
63696 ~Value_t() {clear();}
63697 size_t get_index() const {return type;}
63698 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
63699 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
63700 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
63701 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
63702 Cause& select_id_Cause() { return set<Cause>(3); }
63703 Cause const* get_id_Cause() const { return get<Cause>(3); }
63704 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
63705 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
63706 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
63707 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
63708 bool is_unknown() const { return type == 6; }
63713 case 1: var.destroy<UE_X2AP_ID>(); break;
63714 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
63715 case 3: var.destroy<Cause>(); break;
63716 case 4: var.destroy<CriticalityDiagnostics>(); break;
63717 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
63719 type = 0; ref_nested().clear();
63721 template<typename V> static inline void enumerate(V& v)
63723 v.template operator()<UE_X2AP_ID>(1);
63724 v.template operator()<SgNB_UE_X2AP_ID>(2);
63725 v.template operator()<Cause>(3);
63726 v.template operator()<CriticalityDiagnostics>(4);
63727 v.template operator()<UE_X2AP_ID_Extension>(5);
63731 template<typename V> bool decode(size_t index, V& v)
63736 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
63737 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
63738 case 3: v(select_id_Cause()); return true;
63739 case 4: v(select_id_CriticalityDiagnostics()); return true;
63740 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
63741 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
63746 template<typename V> bool encode(size_t index, V& v) const
63748 if(index != type) return false;
63751 case 1: v(var.as<UE_X2AP_ID>()); return true;
63752 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
63753 case 3: v(var.as<Cause>()); return true;
63754 case 4: v(var.as<CriticalityDiagnostics>()); return true;
63755 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
63761 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63762 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63765 char dummy1[sizeof(Cause)];
63766 char dummy2[sizeof(CriticalityDiagnostics)];
63767 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
63768 char dummy4[sizeof(UE_X2AP_ID)];
63769 char dummy5[sizeof(UE_X2AP_ID_Extension)];
63772 asn::variant<sizeof(union_type)> var;
63776 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63778 size_t get_index() const {return type;}
63779 bool is_unknown() const { return type == 6; }
63780 void clear() {type = 0;}
63781 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63782 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63783 void select_id_Cause() { set(mandatory); type=3;}
63784 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
63785 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
63786 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63787 template<typename V> bool decode(V& v)
63790 if(!v(ref_nested())) return false;
63791 if(equal(mandatory)) { type = 1; return true; }
63792 else if(equal(mandatory)) { type = 2; return true; }
63793 else if(equal(mandatory)) { type = 3; return true; }
63794 else if(equal(optional)) { type = 4; return true; }
63795 else if(equal(optional)) { type = 5; return true; }
63796 else { type = 6; return true;}
63800 template<typename V> bool encode(V& v) const
63802 return v(ref_nested());
63806 template<typename V> bool decode(size_t index, V& v)
63811 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63812 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63813 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
63814 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63815 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63816 case 6: type = 6; return v(ref_nested());
63817 ref_nested().clear();
63822 template<typename V> bool encode(size_t index, V& v) const
63824 if(index != type) {return false;} return v(ref_nested());
63834 SgNBModificationRequestReject ::= SEQUENCE {
63835 protocolIEs ProtocolIE-Container {{SgNBModificationRequestReject-IEs}},
63840 struct SgNBModificationRequestReject : asn::sequence<1, 0, true, 0>
63842 static constexpr const char* name() {return "SgNBModificationRequestReject";}
63843 using parent_t = asn::sequence<1, 0, true, 0>;
63844 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestReject_IEs>
63846 static constexpr const char* name() {return "protocolIEs_t";}
63847 using parent_t = ProtocolIE_Container<SgNBModificationRequestReject_IEs>;
63850 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63851 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63852 template<typename V> void decode(V& v)
63857 template<typename V> void encode(V& v) const
63864 protocolIEs.clear();
63868 protocolIEs_t protocolIEs;
63872 SgNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
63873 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
63874 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
63875 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
63876 { ID id-PDCPChangeIndication CRITICALITY ignore TYPE PDCPChangeIndication PRESENCE optional}|
63877 { ID id-E-RABs-ToBeReleased-SgNBModReqdList CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBModReqdList PRESENCE optional}|
63878 { ID id-SgNBtoMeNBContainer CRITICALITY ignore TYPE SgNBtoMeNBContainer PRESENCE optional}|
63879 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
63880 { ID id-E-RABs-ToBeModified-SgNBModReqdList CRITICALITY ignore TYPE E-RABs-ToBeModified-SgNBModReqdList PRESENCE optional}|
63881 { ID id-SgNBResourceCoordinationInformation CRITICALITY ignore TYPE SgNBResourceCoordinationInformation PRESENCE optional}|
63882 { ID id-RRCConfigIndication CRITICALITY reject TYPE RRC-Config-Ind PRESENCE optional},
63887 struct SgNBModificationRequired_IEs
63889 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63891 size_t get_index() const {return type;}
63892 bool is_unknown() const { return type == 11; }
63893 void clear() {type = 0;}
63894 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63895 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63896 void select_id_Cause() { set(id_Cause); type=3;}
63897 void select_id_PDCPChangeIndication() { set(id_PDCPChangeIndication); type=4;}
63898 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(id_E_RABs_ToBeReleased_SgNBModReqdList); type=5;}
63899 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=6;}
63900 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
63901 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(id_E_RABs_ToBeModified_SgNBModReqdList); type=8;}
63902 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
63903 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
63904 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63905 template<typename V> bool decode(V& v)
63908 if(!v(ref_nested())) return false;
63909 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63910 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63911 else if(equal(id_Cause)) { type = 3; return true; }
63912 else if(equal(id_PDCPChangeIndication)) { type = 4; return true; }
63913 else if(equal(id_E_RABs_ToBeReleased_SgNBModReqdList)) { type = 5; return true; }
63914 else if(equal(id_SgNBtoMeNBContainer)) { type = 6; return true; }
63915 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
63916 else if(equal(id_E_RABs_ToBeModified_SgNBModReqdList)) { type = 8; return true; }
63917 else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
63918 else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
63919 else { type = 11; return true;}
63923 template<typename V> bool encode(V& v) const
63925 return v(ref_nested());
63929 template<typename V> bool decode(size_t index, V& v)
63934 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63935 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63936 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
63937 case 4: type = 4; if(v(ref_nested())) { return equal(id_PDCPChangeIndication);} return false;
63938 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReqdList);} return false;
63939 case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
63940 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63941 case 8: type = 8; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReqdList);} return false;
63942 case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
63943 case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
63944 case 11: type = 11; return v(ref_nested());
63945 ref_nested().clear();
63950 template<typename V> bool encode(size_t index, V& v) const
63952 if(index != type) {return false;} return v(ref_nested());
63959 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63961 size_t get_index() const {return type;}
63962 bool is_unknown() const { return type == 11; }
63963 void clear() {type = 0;}
63964 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
63965 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
63966 void select_id_Cause() { set(ignore); type=3;}
63967 void select_id_PDCPChangeIndication() { set(ignore); type=4;}
63968 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(ignore); type=5;}
63969 void select_id_SgNBtoMeNBContainer() { set(ignore); type=6;}
63970 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
63971 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(ignore); type=8;}
63972 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
63973 void select_id_RRCConfigIndication() { set(reject); type=10;}
63974 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63975 template<typename V> bool decode(V& v)
63978 if(!v(ref_nested())) return false;
63979 if(equal(reject)) { type = 1; return true; }
63980 else if(equal(reject)) { type = 2; return true; }
63981 else if(equal(ignore)) { type = 3; return true; }
63982 else if(equal(ignore)) { type = 4; return true; }
63983 else if(equal(ignore)) { type = 5; return true; }
63984 else if(equal(ignore)) { type = 6; return true; }
63985 else if(equal(reject)) { type = 7; return true; }
63986 else if(equal(ignore)) { type = 8; return true; }
63987 else if(equal(ignore)) { type = 9; return true; }
63988 else if(equal(reject)) { type = 10; return true; }
63989 else { type = 11; return true;}
63993 template<typename V> bool encode(V& v) const
63995 return v(ref_nested());
63999 template<typename V> bool decode(size_t index, V& v)
64004 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64005 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64006 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64007 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64008 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64009 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
64010 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
64011 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
64012 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
64013 case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
64014 case 11: type = 11; return v(ref_nested());
64015 ref_nested().clear();
64020 template<typename V> bool encode(size_t index, V& v) const
64022 if(index != type) {return false;} return v(ref_nested());
64029 struct Value_t : asn::typefield<true>
64031 ~Value_t() {clear();}
64032 size_t get_index() const {return type;}
64033 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64034 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64035 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64036 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64037 Cause& select_id_Cause() { return set<Cause>(3); }
64038 Cause const* get_id_Cause() const { return get<Cause>(3); }
64039 PDCPChangeIndication& select_id_PDCPChangeIndication() { return set<PDCPChangeIndication>(4); }
64040 PDCPChangeIndication const* get_id_PDCPChangeIndication() const { return get<PDCPChangeIndication>(4); }
64041 E_RABs_ToBeReleased_SgNBModReqdList& select_id_E_RABs_ToBeReleased_SgNBModReqdList() { return set<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
64042 E_RABs_ToBeReleased_SgNBModReqdList const* get_id_E_RABs_ToBeReleased_SgNBModReqdList() const { return get<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
64043 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(6); }
64044 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(6); }
64045 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
64046 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
64047 E_RABs_ToBeModified_SgNBModReqdList& select_id_E_RABs_ToBeModified_SgNBModReqdList() { return set<E_RABs_ToBeModified_SgNBModReqdList>(8); }
64048 E_RABs_ToBeModified_SgNBModReqdList const* get_id_E_RABs_ToBeModified_SgNBModReqdList() const { return get<E_RABs_ToBeModified_SgNBModReqdList>(8); }
64049 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
64050 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
64051 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
64052 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
64053 bool is_unknown() const { return type == 11; }
64058 case 1: var.destroy<UE_X2AP_ID>(); break;
64059 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64060 case 3: var.destroy<Cause>(); break;
64061 case 4: var.destroy<PDCPChangeIndication>(); break;
64062 case 5: var.destroy<E_RABs_ToBeReleased_SgNBModReqdList>(); break;
64063 case 6: var.destroy<SgNBtoMeNBContainer>(); break;
64064 case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
64065 case 8: var.destroy<E_RABs_ToBeModified_SgNBModReqdList>(); break;
64066 case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
64067 case 10: var.destroy<RRC_Config_Ind>(); break;
64069 type = 0; ref_nested().clear();
64071 template<typename V> static inline void enumerate(V& v)
64073 v.template operator()<UE_X2AP_ID>(1);
64074 v.template operator()<SgNB_UE_X2AP_ID>(2);
64075 v.template operator()<Cause>(3);
64076 v.template operator()<PDCPChangeIndication>(4);
64077 v.template operator()<E_RABs_ToBeReleased_SgNBModReqdList>(5);
64078 v.template operator()<SgNBtoMeNBContainer>(6);
64079 v.template operator()<UE_X2AP_ID_Extension>(7);
64080 v.template operator()<E_RABs_ToBeModified_SgNBModReqdList>(8);
64081 v.template operator()<SgNBResourceCoordinationInformation>(9);
64082 v.template operator()<RRC_Config_Ind>(10);
64086 template<typename V> bool decode(size_t index, V& v)
64091 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64092 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64093 case 3: v(select_id_Cause()); return true;
64094 case 4: v(select_id_PDCPChangeIndication()); return true;
64095 case 5: v(select_id_E_RABs_ToBeReleased_SgNBModReqdList()); return true;
64096 case 6: v(select_id_SgNBtoMeNBContainer()); return true;
64097 case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64098 case 8: v(select_id_E_RABs_ToBeModified_SgNBModReqdList()); return true;
64099 case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
64100 case 10: v(select_id_RRCConfigIndication()); return true;
64101 case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
64106 template<typename V> bool encode(size_t index, V& v) const
64108 if(index != type) return false;
64111 case 1: v(var.as<UE_X2AP_ID>()); return true;
64112 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64113 case 3: v(var.as<Cause>()); return true;
64114 case 4: v(var.as<PDCPChangeIndication>()); return true;
64115 case 5: v(var.as<E_RABs_ToBeReleased_SgNBModReqdList>()); return true;
64116 case 6: v(var.as<SgNBtoMeNBContainer>()); return true;
64117 case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
64118 case 8: v(var.as<E_RABs_ToBeModified_SgNBModReqdList>()); return true;
64119 case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
64120 case 10: v(var.as<RRC_Config_Ind>()); return true;
64126 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64127 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64130 char dummy1[sizeof(Cause)];
64131 char dummy2[sizeof(E_RABs_ToBeModified_SgNBModReqdList)];
64132 char dummy3[sizeof(E_RABs_ToBeReleased_SgNBModReqdList)];
64133 char dummy4[sizeof(PDCPChangeIndication)];
64134 char dummy5[sizeof(RRC_Config_Ind)];
64135 char dummy6[sizeof(SgNBResourceCoordinationInformation)];
64136 char dummy7[sizeof(SgNB_UE_X2AP_ID)];
64137 char dummy8[sizeof(SgNBtoMeNBContainer)];
64138 char dummy9[sizeof(UE_X2AP_ID)];
64139 char dummy10[sizeof(UE_X2AP_ID_Extension)];
64142 asn::variant<sizeof(union_type)> var;
64146 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64148 size_t get_index() const {return type;}
64149 bool is_unknown() const { return type == 11; }
64150 void clear() {type = 0;}
64151 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64152 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64153 void select_id_Cause() { set(mandatory); type=3;}
64154 void select_id_PDCPChangeIndication() { set(optional); type=4;}
64155 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(optional); type=5;}
64156 void select_id_SgNBtoMeNBContainer() { set(optional); type=6;}
64157 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
64158 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(optional); type=8;}
64159 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
64160 void select_id_RRCConfigIndication() { set(optional); type=10;}
64161 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64162 template<typename V> bool decode(V& v)
64165 if(!v(ref_nested())) return false;
64166 if(equal(mandatory)) { type = 1; return true; }
64167 else if(equal(mandatory)) { type = 2; return true; }
64168 else if(equal(mandatory)) { type = 3; return true; }
64169 else if(equal(optional)) { type = 4; return true; }
64170 else if(equal(optional)) { type = 5; return true; }
64171 else if(equal(optional)) { type = 6; return true; }
64172 else if(equal(optional)) { type = 7; return true; }
64173 else if(equal(optional)) { type = 8; return true; }
64174 else if(equal(optional)) { type = 9; return true; }
64175 else if(equal(optional)) { type = 10; return true; }
64176 else { type = 11; return true;}
64180 template<typename V> bool encode(V& v) const
64182 return v(ref_nested());
64186 template<typename V> bool decode(size_t index, V& v)
64191 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64192 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64193 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
64194 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64195 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
64196 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
64197 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
64198 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
64199 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
64200 case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
64201 case 11: type = 11; return v(ref_nested());
64202 ref_nested().clear();
64207 template<typename V> bool encode(size_t index, V& v) const
64209 if(index != type) {return false;} return v(ref_nested());
64219 SgNBModificationRequired ::= SEQUENCE {
64220 protocolIEs ProtocolIE-Container {{SgNBModificationRequired-IEs}},
64225 struct SgNBModificationRequired : asn::sequence<1, 0, true, 0>
64227 static constexpr const char* name() {return "SgNBModificationRequired";}
64228 using parent_t = asn::sequence<1, 0, true, 0>;
64229 struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequired_IEs>
64231 static constexpr const char* name() {return "protocolIEs_t";}
64232 using parent_t = ProtocolIE_Container<SgNBModificationRequired_IEs>;
64235 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64236 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64237 template<typename V> void decode(V& v)
64242 template<typename V> void encode(V& v) const
64249 protocolIEs.clear();
64253 protocolIEs_t protocolIEs;
64257 SgNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
64258 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
64259 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
64260 { ID id-ResponseInformationSgNBReconfComp CRITICALITY ignore TYPE ResponseInformationSgNBReconfComp PRESENCE mandatory}|
64261 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
64266 struct SgNBReconfigurationComplete_IEs
64268 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64270 size_t get_index() const {return type;}
64271 bool is_unknown() const { return type == 5; }
64272 void clear() {type = 0;}
64273 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64274 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64275 void select_id_ResponseInformationSgNBReconfComp() { set(id_ResponseInformationSgNBReconfComp); type=3;}
64276 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
64277 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64278 template<typename V> bool decode(V& v)
64281 if(!v(ref_nested())) return false;
64282 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64283 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64284 else if(equal(id_ResponseInformationSgNBReconfComp)) { type = 3; return true; }
64285 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
64286 else { type = 5; return true;}
64290 template<typename V> bool encode(V& v) const
64292 return v(ref_nested());
64296 template<typename V> bool decode(size_t index, V& v)
64301 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64302 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64303 case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSgNBReconfComp);} return false;
64304 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64305 case 5: type = 5; return v(ref_nested());
64306 ref_nested().clear();
64311 template<typename V> bool encode(size_t index, V& v) const
64313 if(index != type) {return false;} return v(ref_nested());
64320 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64322 size_t get_index() const {return type;}
64323 bool is_unknown() const { return type == 5; }
64324 void clear() {type = 0;}
64325 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
64326 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
64327 void select_id_ResponseInformationSgNBReconfComp() { set(ignore); type=3;}
64328 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
64329 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64330 template<typename V> bool decode(V& v)
64333 if(!v(ref_nested())) return false;
64334 if(equal(reject)) { type = 1; return true; }
64335 else if(equal(reject)) { type = 2; return true; }
64336 else if(equal(ignore)) { type = 3; return true; }
64337 else if(equal(reject)) { type = 4; return true; }
64338 else { type = 5; return true;}
64342 template<typename V> bool encode(V& v) const
64344 return v(ref_nested());
64348 template<typename V> bool decode(size_t index, V& v)
64353 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64354 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64355 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64356 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
64357 case 5: type = 5; return v(ref_nested());
64358 ref_nested().clear();
64363 template<typename V> bool encode(size_t index, V& v) const
64365 if(index != type) {return false;} return v(ref_nested());
64372 struct Value_t : asn::typefield<true>
64374 ~Value_t() {clear();}
64375 size_t get_index() const {return type;}
64376 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64377 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64378 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64379 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64380 ResponseInformationSgNBReconfComp& select_id_ResponseInformationSgNBReconfComp() { return set<ResponseInformationSgNBReconfComp>(3); }
64381 ResponseInformationSgNBReconfComp const* get_id_ResponseInformationSgNBReconfComp() const { return get<ResponseInformationSgNBReconfComp>(3); }
64382 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
64383 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
64384 bool is_unknown() const { return type == 5; }
64389 case 1: var.destroy<UE_X2AP_ID>(); break;
64390 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64391 case 3: var.destroy<ResponseInformationSgNBReconfComp>(); break;
64392 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
64394 type = 0; ref_nested().clear();
64396 template<typename V> static inline void enumerate(V& v)
64398 v.template operator()<UE_X2AP_ID>(1);
64399 v.template operator()<SgNB_UE_X2AP_ID>(2);
64400 v.template operator()<ResponseInformationSgNBReconfComp>(3);
64401 v.template operator()<UE_X2AP_ID_Extension>(4);
64405 template<typename V> bool decode(size_t index, V& v)
64410 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64411 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64412 case 3: v(select_id_ResponseInformationSgNBReconfComp()); return true;
64413 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64414 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
64419 template<typename V> bool encode(size_t index, V& v) const
64421 if(index != type) return false;
64424 case 1: v(var.as<UE_X2AP_ID>()); return true;
64425 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64426 case 3: v(var.as<ResponseInformationSgNBReconfComp>()); return true;
64427 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
64433 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64434 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64437 char dummy1[sizeof(ResponseInformationSgNBReconfComp)];
64438 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
64439 char dummy3[sizeof(UE_X2AP_ID)];
64440 char dummy4[sizeof(UE_X2AP_ID_Extension)];
64443 asn::variant<sizeof(union_type)> var;
64447 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64449 size_t get_index() const {return type;}
64450 bool is_unknown() const { return type == 5; }
64451 void clear() {type = 0;}
64452 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64453 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64454 void select_id_ResponseInformationSgNBReconfComp() { set(mandatory); type=3;}
64455 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
64456 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64457 template<typename V> bool decode(V& v)
64460 if(!v(ref_nested())) return false;
64461 if(equal(mandatory)) { type = 1; return true; }
64462 else if(equal(mandatory)) { type = 2; return true; }
64463 else if(equal(mandatory)) { type = 3; return true; }
64464 else if(equal(optional)) { type = 4; return true; }
64465 else { type = 5; return true;}
64469 template<typename V> bool encode(V& v) const
64471 return v(ref_nested());
64475 template<typename V> bool decode(size_t index, V& v)
64480 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64481 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64482 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
64483 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64484 case 5: type = 5; return v(ref_nested());
64485 ref_nested().clear();
64490 template<typename V> bool encode(size_t index, V& v) const
64492 if(index != type) {return false;} return v(ref_nested());
64502 SgNBReconfigurationComplete ::= SEQUENCE {
64503 protocolIEs ProtocolIE-Container {{SgNBReconfigurationComplete-IEs}},
64508 struct SgNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
64510 static constexpr const char* name() {return "SgNBReconfigurationComplete";}
64511 using parent_t = asn::sequence<1, 0, true, 0>;
64512 struct protocolIEs_t : ProtocolIE_Container<SgNBReconfigurationComplete_IEs>
64514 static constexpr const char* name() {return "protocolIEs_t";}
64515 using parent_t = ProtocolIE_Container<SgNBReconfigurationComplete_IEs>;
64518 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64519 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64520 template<typename V> void decode(V& v)
64525 template<typename V> void encode(V& v) const
64532 protocolIEs.clear();
64536 protocolIEs_t protocolIEs;
64540 SgNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
64541 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
64542 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
64543 { ID id-E-RABs-ToBeReleased-SgNBRelConfList CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelConfList PRESENCE optional}|
64544 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
64545 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY ignore TYPE UE-X2AP-ID-Extension PRESENCE optional},
64550 struct SgNBReleaseConfirm_IEs
64552 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64554 size_t get_index() const {return type;}
64555 bool is_unknown() const { return type == 6; }
64556 void clear() {type = 0;}
64557 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64558 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64559 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(id_E_RABs_ToBeReleased_SgNBRelConfList); type=3;}
64560 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
64561 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
64562 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64563 template<typename V> bool decode(V& v)
64566 if(!v(ref_nested())) return false;
64567 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64568 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64569 else if(equal(id_E_RABs_ToBeReleased_SgNBRelConfList)) { type = 3; return true; }
64570 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
64571 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
64572 else { type = 6; return true;}
64576 template<typename V> bool encode(V& v) const
64578 return v(ref_nested());
64582 template<typename V> bool decode(size_t index, V& v)
64587 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64588 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64589 case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelConfList);} return false;
64590 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
64591 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64592 case 6: type = 6; return v(ref_nested());
64593 ref_nested().clear();
64598 template<typename V> bool encode(size_t index, V& v) const
64600 if(index != type) {return false;} return v(ref_nested());
64607 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64609 size_t get_index() const {return type;}
64610 bool is_unknown() const { return type == 6; }
64611 void clear() {type = 0;}
64612 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
64613 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
64614 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(ignore); type=3;}
64615 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
64616 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
64617 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64618 template<typename V> bool decode(V& v)
64621 if(!v(ref_nested())) return false;
64622 if(equal(ignore)) { type = 1; return true; }
64623 else if(equal(ignore)) { type = 2; return true; }
64624 else if(equal(ignore)) { type = 3; return true; }
64625 else if(equal(ignore)) { type = 4; return true; }
64626 else if(equal(ignore)) { type = 5; return true; }
64627 else { type = 6; return true;}
64631 template<typename V> bool encode(V& v) const
64633 return v(ref_nested());
64637 template<typename V> bool decode(size_t index, V& v)
64642 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
64643 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
64644 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64645 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64646 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64647 case 6: type = 6; return v(ref_nested());
64648 ref_nested().clear();
64653 template<typename V> bool encode(size_t index, V& v) const
64655 if(index != type) {return false;} return v(ref_nested());
64662 struct Value_t : asn::typefield<true>
64664 ~Value_t() {clear();}
64665 size_t get_index() const {return type;}
64666 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64667 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64668 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64669 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64670 E_RABs_ToBeReleased_SgNBRelConfList& select_id_E_RABs_ToBeReleased_SgNBRelConfList() { return set<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
64671 E_RABs_ToBeReleased_SgNBRelConfList const* get_id_E_RABs_ToBeReleased_SgNBRelConfList() const { return get<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
64672 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
64673 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
64674 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
64675 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
64676 bool is_unknown() const { return type == 6; }
64681 case 1: var.destroy<UE_X2AP_ID>(); break;
64682 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64683 case 3: var.destroy<E_RABs_ToBeReleased_SgNBRelConfList>(); break;
64684 case 4: var.destroy<CriticalityDiagnostics>(); break;
64685 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
64687 type = 0; ref_nested().clear();
64689 template<typename V> static inline void enumerate(V& v)
64691 v.template operator()<UE_X2AP_ID>(1);
64692 v.template operator()<SgNB_UE_X2AP_ID>(2);
64693 v.template operator()<E_RABs_ToBeReleased_SgNBRelConfList>(3);
64694 v.template operator()<CriticalityDiagnostics>(4);
64695 v.template operator()<UE_X2AP_ID_Extension>(5);
64699 template<typename V> bool decode(size_t index, V& v)
64704 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64705 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64706 case 3: v(select_id_E_RABs_ToBeReleased_SgNBRelConfList()); return true;
64707 case 4: v(select_id_CriticalityDiagnostics()); return true;
64708 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64709 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
64714 template<typename V> bool encode(size_t index, V& v) const
64716 if(index != type) return false;
64719 case 1: v(var.as<UE_X2AP_ID>()); return true;
64720 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64721 case 3: v(var.as<E_RABs_ToBeReleased_SgNBRelConfList>()); return true;
64722 case 4: v(var.as<CriticalityDiagnostics>()); return true;
64723 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
64729 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64730 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64733 char dummy1[sizeof(CriticalityDiagnostics)];
64734 char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelConfList)];
64735 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
64736 char dummy4[sizeof(UE_X2AP_ID)];
64737 char dummy5[sizeof(UE_X2AP_ID_Extension)];
64740 asn::variant<sizeof(union_type)> var;
64744 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64746 size_t get_index() const {return type;}
64747 bool is_unknown() const { return type == 6; }
64748 void clear() {type = 0;}
64749 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64750 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64751 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(optional); type=3;}
64752 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
64753 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
64754 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64755 template<typename V> bool decode(V& v)
64758 if(!v(ref_nested())) return false;
64759 if(equal(mandatory)) { type = 1; return true; }
64760 else if(equal(mandatory)) { type = 2; return true; }
64761 else if(equal(optional)) { type = 3; return true; }
64762 else if(equal(optional)) { type = 4; return true; }
64763 else if(equal(optional)) { type = 5; return true; }
64764 else { type = 6; return true;}
64768 template<typename V> bool encode(V& v) const
64770 return v(ref_nested());
64774 template<typename V> bool decode(size_t index, V& v)
64779 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64780 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64781 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
64782 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64783 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
64784 case 6: type = 6; return v(ref_nested());
64785 ref_nested().clear();
64790 template<typename V> bool encode(size_t index, V& v) const
64792 if(index != type) {return false;} return v(ref_nested());
64802 SgNBReleaseConfirm ::= SEQUENCE {
64803 protocolIEs ProtocolIE-Container {{SgNBReleaseConfirm-IEs}},
64808 struct SgNBReleaseConfirm : asn::sequence<1, 0, true, 0>
64810 static constexpr const char* name() {return "SgNBReleaseConfirm";}
64811 using parent_t = asn::sequence<1, 0, true, 0>;
64812 struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseConfirm_IEs>
64814 static constexpr const char* name() {return "protocolIEs_t";}
64815 using parent_t = ProtocolIE_Container<SgNBReleaseConfirm_IEs>;
64818 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64819 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64820 template<typename V> void decode(V& v)
64825 template<typename V> void encode(V& v) const
64832 protocolIEs.clear();
64836 protocolIEs_t protocolIEs;
64840 SgNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
64841 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
64842 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE optional}|
64843 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
64844 { ID id-E-RABs-ToBeReleased-SgNBRelReqList CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelReqList PRESENCE optional}|
64845 { ID id-UE-ContextKeptIndicator CRITICALITY ignore TYPE UE-ContextKeptIndicator PRESENCE optional}|
64846 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
64847 { ID id-MeNBtoSgNBContainer CRITICALITY reject TYPE MeNBtoSgNBContainer PRESENCE optional},
64852 struct SgNBReleaseRequest_IEs
64854 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64856 size_t get_index() const {return type;}
64857 bool is_unknown() const { return type == 8; }
64858 void clear() {type = 0;}
64859 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64860 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64861 void select_id_Cause() { set(id_Cause); type=3;}
64862 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(id_E_RABs_ToBeReleased_SgNBRelReqList); type=4;}
64863 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
64864 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
64865 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=7;}
64866 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64867 template<typename V> bool decode(V& v)
64870 if(!v(ref_nested())) return false;
64871 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64872 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64873 else if(equal(id_Cause)) { type = 3; return true; }
64874 else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqList)) { type = 4; return true; }
64875 else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
64876 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
64877 else if(equal(id_MeNBtoSgNBContainer)) { type = 7; return true; }
64878 else { type = 8; return true;}
64882 template<typename V> bool encode(V& v) const
64884 return v(ref_nested());
64888 template<typename V> bool decode(size_t index, V& v)
64893 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64894 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64895 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
64896 case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqList);} return false;
64897 case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
64898 case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64899 case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
64900 case 8: type = 8; return v(ref_nested());
64901 ref_nested().clear();
64906 template<typename V> bool encode(size_t index, V& v) const
64908 if(index != type) {return false;} return v(ref_nested());
64915 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64917 size_t get_index() const {return type;}
64918 bool is_unknown() const { return type == 8; }
64919 void clear() {type = 0;}
64920 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
64921 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
64922 void select_id_Cause() { set(ignore); type=3;}
64923 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(ignore); type=4;}
64924 void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
64925 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
64926 void select_id_MeNBtoSgNBContainer() { set(reject); type=7;}
64927 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64928 template<typename V> bool decode(V& v)
64931 if(!v(ref_nested())) return false;
64932 if(equal(reject)) { type = 1; return true; }
64933 else if(equal(reject)) { type = 2; return true; }
64934 else if(equal(ignore)) { type = 3; return true; }
64935 else if(equal(ignore)) { type = 4; return true; }
64936 else if(equal(ignore)) { type = 5; return true; }
64937 else if(equal(reject)) { type = 6; return true; }
64938 else if(equal(reject)) { type = 7; return true; }
64939 else { type = 8; return true;}
64943 template<typename V> bool encode(V& v) const
64945 return v(ref_nested());
64949 template<typename V> bool decode(size_t index, V& v)
64954 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64955 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64956 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64957 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64958 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64959 case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
64960 case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
64961 case 8: type = 8; return v(ref_nested());
64962 ref_nested().clear();
64967 template<typename V> bool encode(size_t index, V& v) const
64969 if(index != type) {return false;} return v(ref_nested());
64976 struct Value_t : asn::typefield<true>
64978 ~Value_t() {clear();}
64979 size_t get_index() const {return type;}
64980 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64981 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64982 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64983 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64984 Cause& select_id_Cause() { return set<Cause>(3); }
64985 Cause const* get_id_Cause() const { return get<Cause>(3); }
64986 E_RABs_ToBeReleased_SgNBRelReqList& select_id_E_RABs_ToBeReleased_SgNBRelReqList() { return set<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
64987 E_RABs_ToBeReleased_SgNBRelReqList const* get_id_E_RABs_ToBeReleased_SgNBRelReqList() const { return get<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
64988 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
64989 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
64990 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
64991 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
64992 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(7); }
64993 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(7); }
64994 bool is_unknown() const { return type == 8; }
64999 case 1: var.destroy<UE_X2AP_ID>(); break;
65000 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65001 case 3: var.destroy<Cause>(); break;
65002 case 4: var.destroy<E_RABs_ToBeReleased_SgNBRelReqList>(); break;
65003 case 5: var.destroy<UE_ContextKeptIndicator>(); break;
65004 case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
65005 case 7: var.destroy<MeNBtoSgNBContainer>(); break;
65007 type = 0; ref_nested().clear();
65009 template<typename V> static inline void enumerate(V& v)
65011 v.template operator()<UE_X2AP_ID>(1);
65012 v.template operator()<SgNB_UE_X2AP_ID>(2);
65013 v.template operator()<Cause>(3);
65014 v.template operator()<E_RABs_ToBeReleased_SgNBRelReqList>(4);
65015 v.template operator()<UE_ContextKeptIndicator>(5);
65016 v.template operator()<UE_X2AP_ID_Extension>(6);
65017 v.template operator()<MeNBtoSgNBContainer>(7);
65021 template<typename V> bool decode(size_t index, V& v)
65026 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65027 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65028 case 3: v(select_id_Cause()); return true;
65029 case 4: v(select_id_E_RABs_ToBeReleased_SgNBRelReqList()); return true;
65030 case 5: v(select_id_UE_ContextKeptIndicator()); return true;
65031 case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65032 case 7: v(select_id_MeNBtoSgNBContainer()); return true;
65033 case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
65038 template<typename V> bool encode(size_t index, V& v) const
65040 if(index != type) return false;
65043 case 1: v(var.as<UE_X2AP_ID>()); return true;
65044 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65045 case 3: v(var.as<Cause>()); return true;
65046 case 4: v(var.as<E_RABs_ToBeReleased_SgNBRelReqList>()); return true;
65047 case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
65048 case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
65049 case 7: v(var.as<MeNBtoSgNBContainer>()); return true;
65055 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65056 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65059 char dummy1[sizeof(Cause)];
65060 char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelReqList)];
65061 char dummy3[sizeof(MeNBtoSgNBContainer)];
65062 char dummy4[sizeof(SgNB_UE_X2AP_ID)];
65063 char dummy5[sizeof(UE_ContextKeptIndicator)];
65064 char dummy6[sizeof(UE_X2AP_ID)];
65065 char dummy7[sizeof(UE_X2AP_ID_Extension)];
65068 asn::variant<sizeof(union_type)> var;
65072 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65074 size_t get_index() const {return type;}
65075 bool is_unknown() const { return type == 8; }
65076 void clear() {type = 0;}
65077 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65078 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
65079 void select_id_Cause() { set(mandatory); type=3;}
65080 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(optional); type=4;}
65081 void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
65082 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
65083 void select_id_MeNBtoSgNBContainer() { set(optional); type=7;}
65084 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65085 template<typename V> bool decode(V& v)
65088 if(!v(ref_nested())) return false;
65089 if(equal(mandatory)) { type = 1; return true; }
65090 else if(equal(optional)) { type = 2; return true; }
65091 else if(equal(mandatory)) { type = 3; return true; }
65092 else if(equal(optional)) { type = 4; return true; }
65093 else if(equal(optional)) { type = 5; return true; }
65094 else if(equal(optional)) { type = 6; return true; }
65095 else if(equal(optional)) { type = 7; return true; }
65096 else { type = 8; return true;}
65100 template<typename V> bool encode(V& v) const
65102 return v(ref_nested());
65106 template<typename V> bool decode(size_t index, V& v)
65111 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65112 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
65113 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
65114 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65115 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65116 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
65117 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
65118 case 8: type = 8; return v(ref_nested());
65119 ref_nested().clear();
65124 template<typename V> bool encode(size_t index, V& v) const
65126 if(index != type) {return false;} return v(ref_nested());
65136 SgNBReleaseRequest ::= SEQUENCE {
65137 protocolIEs ProtocolIE-Container {{SgNBReleaseRequest-IEs}},
65142 struct SgNBReleaseRequest : asn::sequence<1, 0, true, 0>
65144 static constexpr const char* name() {return "SgNBReleaseRequest";}
65145 using parent_t = asn::sequence<1, 0, true, 0>;
65146 struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequest_IEs>
65148 static constexpr const char* name() {return "protocolIEs_t";}
65149 using parent_t = ProtocolIE_Container<SgNBReleaseRequest_IEs>;
65152 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65153 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65154 template<typename V> void decode(V& v)
65159 template<typename V> void encode(V& v) const
65166 protocolIEs.clear();
65170 protocolIEs_t protocolIEs;
65174 SgNBReleaseRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
65175 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
65176 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
65177 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional }|
65178 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional }|
65179 { ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList CRITICALITY ignore TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList PRESENCE optional },
65184 struct SgNBReleaseRequestAcknowledge_IEs
65186 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65188 size_t get_index() const {return type;}
65189 bool is_unknown() const { return type == 6; }
65190 void clear() {type = 0;}
65191 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65192 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65193 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
65194 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
65195 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList); type=5;}
65196 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65197 template<typename V> bool decode(V& v)
65200 if(!v(ref_nested())) return false;
65201 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65202 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65203 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
65204 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
65205 else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)) { type = 5; return true; }
65206 else { type = 6; return true;}
65210 template<typename V> bool encode(V& v) const
65212 return v(ref_nested());
65216 template<typename V> bool decode(size_t index, V& v)
65221 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65222 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65223 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
65224 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65225 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList);} return false;
65226 case 6: type = 6; return v(ref_nested());
65227 ref_nested().clear();
65232 template<typename V> bool encode(size_t index, V& v) const
65234 if(index != type) {return false;} return v(ref_nested());
65241 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65243 size_t get_index() const {return type;}
65244 bool is_unknown() const { return type == 6; }
65245 void clear() {type = 0;}
65246 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
65247 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
65248 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
65249 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
65250 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(ignore); type=5;}
65251 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65252 template<typename V> bool decode(V& v)
65255 if(!v(ref_nested())) return false;
65256 if(equal(ignore)) { type = 1; return true; }
65257 else if(equal(ignore)) { type = 2; return true; }
65258 else if(equal(ignore)) { type = 3; return true; }
65259 else if(equal(reject)) { type = 4; return true; }
65260 else if(equal(ignore)) { type = 5; return true; }
65261 else { type = 6; return true;}
65265 template<typename V> bool encode(V& v) const
65267 return v(ref_nested());
65271 template<typename V> bool decode(size_t index, V& v)
65276 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
65277 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
65278 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65279 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
65280 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
65281 case 6: type = 6; return v(ref_nested());
65282 ref_nested().clear();
65287 template<typename V> bool encode(size_t index, V& v) const
65289 if(index != type) {return false;} return v(ref_nested());
65296 struct Value_t : asn::typefield<true>
65298 ~Value_t() {clear();}
65299 size_t get_index() const {return type;}
65300 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65301 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65302 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65303 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65304 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
65305 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
65306 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
65307 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
65308 E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
65309 E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
65310 bool is_unknown() const { return type == 6; }
65315 case 1: var.destroy<UE_X2AP_ID>(); break;
65316 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65317 case 3: var.destroy<CriticalityDiagnostics>(); break;
65318 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
65319 case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(); break;
65321 type = 0; ref_nested().clear();
65323 template<typename V> static inline void enumerate(V& v)
65325 v.template operator()<UE_X2AP_ID>(1);
65326 v.template operator()<SgNB_UE_X2AP_ID>(2);
65327 v.template operator()<CriticalityDiagnostics>(3);
65328 v.template operator()<UE_X2AP_ID_Extension>(4);
65329 v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5);
65333 template<typename V> bool decode(size_t index, V& v)
65338 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65339 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65340 case 3: v(select_id_CriticalityDiagnostics()); return true;
65341 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65342 case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList()); return true;
65343 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65348 template<typename V> bool encode(size_t index, V& v) const
65350 if(index != type) return false;
65353 case 1: v(var.as<UE_X2AP_ID>()); return true;
65354 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65355 case 3: v(var.as<CriticalityDiagnostics>()); return true;
65356 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
65357 case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>()); return true;
65363 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65364 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65367 char dummy1[sizeof(CriticalityDiagnostics)];
65368 char dummy2[sizeof(E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)];
65369 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65370 char dummy4[sizeof(UE_X2AP_ID)];
65371 char dummy5[sizeof(UE_X2AP_ID_Extension)];
65374 asn::variant<sizeof(union_type)> var;
65378 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65380 size_t get_index() const {return type;}
65381 bool is_unknown() const { return type == 6; }
65382 void clear() {type = 0;}
65383 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65384 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65385 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
65386 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
65387 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(optional); type=5;}
65388 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65389 template<typename V> bool decode(V& v)
65392 if(!v(ref_nested())) return false;
65393 if(equal(mandatory)) { type = 1; return true; }
65394 else if(equal(mandatory)) { type = 2; return true; }
65395 else if(equal(optional)) { type = 3; return true; }
65396 else if(equal(optional)) { type = 4; return true; }
65397 else if(equal(optional)) { type = 5; return true; }
65398 else { type = 6; return true;}
65402 template<typename V> bool encode(V& v) const
65404 return v(ref_nested());
65408 template<typename V> bool decode(size_t index, V& v)
65413 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65414 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
65415 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
65416 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65417 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65418 case 6: type = 6; return v(ref_nested());
65419 ref_nested().clear();
65424 template<typename V> bool encode(size_t index, V& v) const
65426 if(index != type) {return false;} return v(ref_nested());
65436 SgNBReleaseRequestAcknowledge ::= SEQUENCE {
65437 protocolIEs ProtocolIE-Container {{SgNBReleaseRequestAcknowledge-IEs}},
65442 struct SgNBReleaseRequestAcknowledge : asn::sequence<1, 0, true, 0>
65444 static constexpr const char* name() {return "SgNBReleaseRequestAcknowledge";}
65445 using parent_t = asn::sequence<1, 0, true, 0>;
65446 struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>
65448 static constexpr const char* name() {return "protocolIEs_t";}
65449 using parent_t = ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>;
65452 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65453 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65454 template<typename V> void decode(V& v)
65459 template<typename V> void encode(V& v) const
65466 protocolIEs.clear();
65470 protocolIEs_t protocolIEs;
65474 SgNBReleaseRequestReject-IEs X2AP-PROTOCOL-IES ::= {
65475 { ID id-MeNB-UE-X2AP-ID CRITICALITY ignore TYPE UE-X2AP-ID PRESENCE mandatory}|
65476 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
65477 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
65478 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
65479 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional},
65484 struct SgNBReleaseRequestReject_IEs
65486 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65488 size_t get_index() const {return type;}
65489 bool is_unknown() const { return type == 6; }
65490 void clear() {type = 0;}
65491 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65492 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65493 void select_id_Cause() { set(id_Cause); type=3;}
65494 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
65495 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
65496 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65497 template<typename V> bool decode(V& v)
65500 if(!v(ref_nested())) return false;
65501 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65502 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65503 else if(equal(id_Cause)) { type = 3; return true; }
65504 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
65505 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
65506 else { type = 6; return true;}
65510 template<typename V> bool encode(V& v) const
65512 return v(ref_nested());
65516 template<typename V> bool decode(size_t index, V& v)
65521 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65522 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65523 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
65524 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
65525 case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65526 case 6: type = 6; return v(ref_nested());
65527 ref_nested().clear();
65532 template<typename V> bool encode(size_t index, V& v) const
65534 if(index != type) {return false;} return v(ref_nested());
65541 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65543 size_t get_index() const {return type;}
65544 bool is_unknown() const { return type == 6; }
65545 void clear() {type = 0;}
65546 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
65547 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
65548 void select_id_Cause() { set(ignore); type=3;}
65549 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
65550 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
65551 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65552 template<typename V> bool decode(V& v)
65555 if(!v(ref_nested())) return false;
65556 if(equal(ignore)) { type = 1; return true; }
65557 else if(equal(ignore)) { type = 2; return true; }
65558 else if(equal(ignore)) { type = 3; return true; }
65559 else if(equal(ignore)) { type = 4; return true; }
65560 else if(equal(reject)) { type = 5; return true; }
65561 else { type = 6; return true;}
65565 template<typename V> bool encode(V& v) const
65567 return v(ref_nested());
65571 template<typename V> bool decode(size_t index, V& v)
65576 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
65577 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
65578 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65579 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
65580 case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
65581 case 6: type = 6; return v(ref_nested());
65582 ref_nested().clear();
65587 template<typename V> bool encode(size_t index, V& v) const
65589 if(index != type) {return false;} return v(ref_nested());
65596 struct Value_t : asn::typefield<true>
65598 ~Value_t() {clear();}
65599 size_t get_index() const {return type;}
65600 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65601 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65602 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65603 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65604 Cause& select_id_Cause() { return set<Cause>(3); }
65605 Cause const* get_id_Cause() const { return get<Cause>(3); }
65606 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
65607 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
65608 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
65609 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
65610 bool is_unknown() const { return type == 6; }
65615 case 1: var.destroy<UE_X2AP_ID>(); break;
65616 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65617 case 3: var.destroy<Cause>(); break;
65618 case 4: var.destroy<CriticalityDiagnostics>(); break;
65619 case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
65621 type = 0; ref_nested().clear();
65623 template<typename V> static inline void enumerate(V& v)
65625 v.template operator()<UE_X2AP_ID>(1);
65626 v.template operator()<SgNB_UE_X2AP_ID>(2);
65627 v.template operator()<Cause>(3);
65628 v.template operator()<CriticalityDiagnostics>(4);
65629 v.template operator()<UE_X2AP_ID_Extension>(5);
65633 template<typename V> bool decode(size_t index, V& v)
65638 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65639 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65640 case 3: v(select_id_Cause()); return true;
65641 case 4: v(select_id_CriticalityDiagnostics()); return true;
65642 case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65643 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65648 template<typename V> bool encode(size_t index, V& v) const
65650 if(index != type) return false;
65653 case 1: v(var.as<UE_X2AP_ID>()); return true;
65654 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65655 case 3: v(var.as<Cause>()); return true;
65656 case 4: v(var.as<CriticalityDiagnostics>()); return true;
65657 case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
65663 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65664 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65667 char dummy1[sizeof(Cause)];
65668 char dummy2[sizeof(CriticalityDiagnostics)];
65669 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65670 char dummy4[sizeof(UE_X2AP_ID)];
65671 char dummy5[sizeof(UE_X2AP_ID_Extension)];
65674 asn::variant<sizeof(union_type)> var;
65678 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65680 size_t get_index() const {return type;}
65681 bool is_unknown() const { return type == 6; }
65682 void clear() {type = 0;}
65683 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65684 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65685 void select_id_Cause() { set(mandatory); type=3;}
65686 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
65687 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
65688 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65689 template<typename V> bool decode(V& v)
65692 if(!v(ref_nested())) return false;
65693 if(equal(mandatory)) { type = 1; return true; }
65694 else if(equal(mandatory)) { type = 2; return true; }
65695 else if(equal(mandatory)) { type = 3; return true; }
65696 else if(equal(optional)) { type = 4; return true; }
65697 else if(equal(optional)) { type = 5; return true; }
65698 else { type = 6; return true;}
65702 template<typename V> bool encode(V& v) const
65704 return v(ref_nested());
65708 template<typename V> bool decode(size_t index, V& v)
65713 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65714 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
65715 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
65716 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65717 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65718 case 6: type = 6; return v(ref_nested());
65719 ref_nested().clear();
65724 template<typename V> bool encode(size_t index, V& v) const
65726 if(index != type) {return false;} return v(ref_nested());
65736 SgNBReleaseRequestReject ::= SEQUENCE {
65737 protocolIEs ProtocolIE-Container {{SgNBReleaseRequestReject-IEs}},
65742 struct SgNBReleaseRequestReject : asn::sequence<1, 0, true, 0>
65744 static constexpr const char* name() {return "SgNBReleaseRequestReject";}
65745 using parent_t = asn::sequence<1, 0, true, 0>;
65746 struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestReject_IEs>
65748 static constexpr const char* name() {return "protocolIEs_t";}
65749 using parent_t = ProtocolIE_Container<SgNBReleaseRequestReject_IEs>;
65752 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65753 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65754 template<typename V> void decode(V& v)
65759 template<typename V> void encode(V& v) const
65766 protocolIEs.clear();
65770 protocolIEs_t protocolIEs;
65774 SgNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
65775 { ID id-MeNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
65776 { ID id-SgNB-UE-X2AP-ID CRITICALITY reject TYPE SgNB-UE-X2AP-ID PRESENCE mandatory}|
65777 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
65778 { ID id-MeNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional }|
65779 { ID id-E-RABs-ToBeReleased-SgNBRelReqdList CRITICALITY ignore TYPE E-RABs-ToBeReleased-SgNBRelReqdList PRESENCE optional },
65784 struct SgNBReleaseRequired_IEs
65786 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65788 size_t get_index() const {return type;}
65789 bool is_unknown() const { return type == 6; }
65790 void clear() {type = 0;}
65791 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65792 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65793 void select_id_Cause() { set(id_Cause); type=3;}
65794 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
65795 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(id_E_RABs_ToBeReleased_SgNBRelReqdList); type=5;}
65796 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65797 template<typename V> bool decode(V& v)
65800 if(!v(ref_nested())) return false;
65801 if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65802 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65803 else if(equal(id_Cause)) { type = 3; return true; }
65804 else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
65805 else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqdList)) { type = 5; return true; }
65806 else { type = 6; return true;}
65810 template<typename V> bool encode(V& v) const
65812 return v(ref_nested());
65816 template<typename V> bool decode(size_t index, V& v)
65821 case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65822 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65823 case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
65824 case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65825 case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqdList);} return false;
65826 case 6: type = 6; return v(ref_nested());
65827 ref_nested().clear();
65832 template<typename V> bool encode(size_t index, V& v) const
65834 if(index != type) {return false;} return v(ref_nested());
65841 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65843 size_t get_index() const {return type;}
65844 bool is_unknown() const { return type == 6; }
65845 void clear() {type = 0;}
65846 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
65847 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
65848 void select_id_Cause() { set(ignore); type=3;}
65849 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
65850 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(ignore); type=5;}
65851 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65852 template<typename V> bool decode(V& v)
65855 if(!v(ref_nested())) return false;
65856 if(equal(reject)) { type = 1; return true; }
65857 else if(equal(reject)) { type = 2; return true; }
65858 else if(equal(ignore)) { type = 3; return true; }
65859 else if(equal(reject)) { type = 4; return true; }
65860 else if(equal(ignore)) { type = 5; return true; }
65861 else { type = 6; return true;}
65865 template<typename V> bool encode(V& v) const
65867 return v(ref_nested());
65871 template<typename V> bool decode(size_t index, V& v)
65876 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
65877 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
65878 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65879 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
65880 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
65881 case 6: type = 6; return v(ref_nested());
65882 ref_nested().clear();
65887 template<typename V> bool encode(size_t index, V& v) const
65889 if(index != type) {return false;} return v(ref_nested());
65896 struct Value_t : asn::typefield<true>
65898 ~Value_t() {clear();}
65899 size_t get_index() const {return type;}
65900 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65901 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65902 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65903 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65904 Cause& select_id_Cause() { return set<Cause>(3); }
65905 Cause const* get_id_Cause() const { return get<Cause>(3); }
65906 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
65907 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
65908 E_RABs_ToBeReleased_SgNBRelReqdList& select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { return set<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
65909 E_RABs_ToBeReleased_SgNBRelReqdList const* get_id_E_RABs_ToBeReleased_SgNBRelReqdList() const { return get<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
65910 bool is_unknown() const { return type == 6; }
65915 case 1: var.destroy<UE_X2AP_ID>(); break;
65916 case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65917 case 3: var.destroy<Cause>(); break;
65918 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
65919 case 5: var.destroy<E_RABs_ToBeReleased_SgNBRelReqdList>(); break;
65921 type = 0; ref_nested().clear();
65923 template<typename V> static inline void enumerate(V& v)
65925 v.template operator()<UE_X2AP_ID>(1);
65926 v.template operator()<SgNB_UE_X2AP_ID>(2);
65927 v.template operator()<Cause>(3);
65928 v.template operator()<UE_X2AP_ID_Extension>(4);
65929 v.template operator()<E_RABs_ToBeReleased_SgNBRelReqdList>(5);
65933 template<typename V> bool decode(size_t index, V& v)
65938 case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65939 case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65940 case 3: v(select_id_Cause()); return true;
65941 case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65942 case 5: v(select_id_E_RABs_ToBeReleased_SgNBRelReqdList()); return true;
65943 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65948 template<typename V> bool encode(size_t index, V& v) const
65950 if(index != type) return false;
65953 case 1: v(var.as<UE_X2AP_ID>()); return true;
65954 case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65955 case 3: v(var.as<Cause>()); return true;
65956 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
65957 case 5: v(var.as<E_RABs_ToBeReleased_SgNBRelReqdList>()); return true;
65963 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65964 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65967 char dummy1[sizeof(Cause)];
65968 char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelReqdList)];
65969 char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65970 char dummy4[sizeof(UE_X2AP_ID)];
65971 char dummy5[sizeof(UE_X2AP_ID_Extension)];
65974 asn::variant<sizeof(union_type)> var;
65978 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65980 size_t get_index() const {return type;}
65981 bool is_unknown() const { return type == 6; }
65982 void clear() {type = 0;}
65983 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65984 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65985 void select_id_Cause() { set(mandatory); type=3;}
65986 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
65987 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(optional); type=5;}
65988 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65989 template<typename V> bool decode(V& v)
65992 if(!v(ref_nested())) return false;
65993 if(equal(mandatory)) { type = 1; return true; }
65994 else if(equal(mandatory)) { type = 2; return true; }
65995 else if(equal(mandatory)) { type = 3; return true; }
65996 else if(equal(optional)) { type = 4; return true; }
65997 else if(equal(optional)) { type = 5; return true; }
65998 else { type = 6; return true;}
66002 template<typename V> bool encode(V& v) const
66004 return v(ref_nested());
66008 template<typename V> bool decode(size_t index, V& v)
66013 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66014 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
66015 case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
66016 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
66017 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
66018 case 6: type = 6; return v(ref_nested());
66019 ref_nested().clear();
66024 template<typename V> bool encode(size_t index, V& v) const
66026 if(index != type) {return false;} return v(ref_nested());
66036 SgNBReleaseRequired ::= SEQUENCE {
66037 protocolIEs ProtocolIE-Container {{SgNBReleaseRequired-IEs}},
66042 struct SgNBReleaseRequired : asn::sequence<1, 0, true, 0>
66044 static constexpr const char* name() {return "SgNBReleaseRequired";}
66045 using parent_t = asn::sequence<1, 0, true, 0>;
66046 struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequired_IEs>
66048 static constexpr const char* name() {return "protocolIEs_t";}
66049 using parent_t = ProtocolIE_Container<SgNBReleaseRequired_IEs>;
66052 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66053 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66054 template<typename V> void decode(V& v)
66059 template<typename V> void encode(V& v) const
66066 protocolIEs.clear();
66070 protocolIEs_t protocolIEs;
66074 UEContextRelease-IEs X2AP-PROTOCOL-IES ::= {
66075 { ID id-Old-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
66076 { ID id-New-eNB-UE-X2AP-ID CRITICALITY reject TYPE UE-X2AP-ID PRESENCE mandatory}|
66077 { ID id-Old-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
66078 { ID id-New-eNB-UE-X2AP-ID-Extension CRITICALITY reject TYPE UE-X2AP-ID-Extension PRESENCE optional}|
66079 { ID id-SIPTO-BearerDeactivationIndication CRITICALITY ignore TYPE SIPTOBearerDeactivationIndication PRESENCE optional}|
66080 { ID id-SgNB-UE-X2AP-ID CRITICALITY ignore TYPE SgNB-UE-X2AP-ID PRESENCE optional},
66085 struct UEContextRelease_IEs
66087 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66089 size_t get_index() const {return type;}
66090 bool is_unknown() const { return type == 7; }
66091 void clear() {type = 0;}
66092 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
66093 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
66094 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
66095 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=4;}
66096 void select_id_SIPTO_BearerDeactivationIndication() { set(id_SIPTO_BearerDeactivationIndication); type=5;}
66097 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
66098 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66099 template<typename V> bool decode(V& v)
66102 if(!v(ref_nested())) return false;
66103 if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
66104 else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
66105 else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
66106 else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
66107 else if(equal(id_SIPTO_BearerDeactivationIndication)) { type = 5; return true; }
66108 else if(equal(id_SgNB_UE_X2AP_ID)) { type = 6; return true; }
66109 else { type = 7; return true;}
66113 template<typename V> bool encode(V& v) const
66115 return v(ref_nested());
66119 template<typename V> bool decode(size_t index, V& v)
66124 case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
66125 case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
66126 case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
66127 case 4: type = 4; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
66128 case 5: type = 5; if(v(ref_nested())) { return equal(id_SIPTO_BearerDeactivationIndication);} return false;
66129 case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
66130 case 7: type = 7; return v(ref_nested());
66131 ref_nested().clear();
66136 template<typename V> bool encode(size_t index, V& v) const
66138 if(index != type) {return false;} return v(ref_nested());
66145 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66147 size_t get_index() const {return type;}
66148 bool is_unknown() const { return type == 7; }
66149 void clear() {type = 0;}
66150 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
66151 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
66152 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=3;}
66153 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
66154 void select_id_SIPTO_BearerDeactivationIndication() { set(ignore); type=5;}
66155 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
66156 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66157 template<typename V> bool decode(V& v)
66160 if(!v(ref_nested())) return false;
66161 if(equal(reject)) { type = 1; return true; }
66162 else if(equal(reject)) { type = 2; return true; }
66163 else if(equal(reject)) { type = 3; return true; }
66164 else if(equal(reject)) { type = 4; return true; }
66165 else if(equal(ignore)) { type = 5; return true; }
66166 else if(equal(ignore)) { type = 6; return true; }
66167 else { type = 7; return true;}
66171 template<typename V> bool encode(V& v) const
66173 return v(ref_nested());
66177 template<typename V> bool decode(size_t index, V& v)
66182 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66183 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
66184 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
66185 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
66186 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
66187 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
66188 case 7: type = 7; return v(ref_nested());
66189 ref_nested().clear();
66194 template<typename V> bool encode(size_t index, V& v) const
66196 if(index != type) {return false;} return v(ref_nested());
66203 struct Value_t : asn::typefield<true>
66205 ~Value_t() {clear();}
66206 size_t get_index() const {return type;}
66207 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
66208 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
66209 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
66210 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
66211 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
66212 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
66213 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
66214 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
66215 SIPTOBearerDeactivationIndication& select_id_SIPTO_BearerDeactivationIndication() { return set<SIPTOBearerDeactivationIndication>(5); }
66216 SIPTOBearerDeactivationIndication const* get_id_SIPTO_BearerDeactivationIndication() const { return get<SIPTOBearerDeactivationIndication>(5); }
66217 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
66218 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
66219 bool is_unknown() const { return type == 7; }
66224 case 1: var.destroy<UE_X2AP_ID>(); break;
66225 case 2: var.destroy<UE_X2AP_ID>(); break;
66226 case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
66227 case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
66228 case 5: var.destroy<SIPTOBearerDeactivationIndication>(); break;
66229 case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
66231 type = 0; ref_nested().clear();
66233 template<typename V> static inline void enumerate(V& v)
66235 v.template operator()<UE_X2AP_ID>(1);
66236 v.template operator()<UE_X2AP_ID>(2);
66237 v.template operator()<UE_X2AP_ID_Extension>(3);
66238 v.template operator()<UE_X2AP_ID_Extension>(4);
66239 v.template operator()<SIPTOBearerDeactivationIndication>(5);
66240 v.template operator()<SgNB_UE_X2AP_ID>(6);
66244 template<typename V> bool decode(size_t index, V& v)
66249 case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
66250 case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
66251 case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
66252 case 4: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
66253 case 5: v(select_id_SIPTO_BearerDeactivationIndication()); return true;
66254 case 6: v(select_id_SgNB_UE_X2AP_ID()); return true;
66255 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
66260 template<typename V> bool encode(size_t index, V& v) const
66262 if(index != type) return false;
66265 case 1: v(var.as<UE_X2AP_ID>()); return true;
66266 case 2: v(var.as<UE_X2AP_ID>()); return true;
66267 case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
66268 case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
66269 case 5: v(var.as<SIPTOBearerDeactivationIndication>()); return true;
66270 case 6: v(var.as<SgNB_UE_X2AP_ID>()); return true;
66276 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66277 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66280 char dummy1[sizeof(SIPTOBearerDeactivationIndication)];
66281 char dummy2[sizeof(SgNB_UE_X2AP_ID)];
66282 char dummy3[sizeof(UE_X2AP_ID)];
66283 char dummy4[sizeof(UE_X2AP_ID_Extension)];
66286 asn::variant<sizeof(union_type)> var;
66290 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66292 size_t get_index() const {return type;}
66293 bool is_unknown() const { return type == 7; }
66294 void clear() {type = 0;}
66295 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
66296 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
66297 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
66298 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
66299 void select_id_SIPTO_BearerDeactivationIndication() { set(optional); type=5;}
66300 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
66301 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66302 template<typename V> bool decode(V& v)
66305 if(!v(ref_nested())) return false;
66306 if(equal(mandatory)) { type = 1; return true; }
66307 else if(equal(mandatory)) { type = 2; return true; }
66308 else if(equal(optional)) { type = 3; return true; }
66309 else if(equal(optional)) { type = 4; return true; }
66310 else if(equal(optional)) { type = 5; return true; }
66311 else if(equal(optional)) { type = 6; return true; }
66312 else { type = 7; return true;}
66316 template<typename V> bool encode(V& v) const
66318 return v(ref_nested());
66322 template<typename V> bool decode(size_t index, V& v)
66327 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66328 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
66329 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
66330 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
66331 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
66332 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
66333 case 7: type = 7; return v(ref_nested());
66334 ref_nested().clear();
66339 template<typename V> bool encode(size_t index, V& v) const
66341 if(index != type) {return false;} return v(ref_nested());
66351 UEContextRelease ::= SEQUENCE {
66352 protocolIEs ProtocolIE-Container {{UEContextRelease-IEs}},
66357 struct UEContextRelease : asn::sequence<1, 0, true, 0>
66359 static constexpr const char* name() {return "UEContextRelease";}
66360 using parent_t = asn::sequence<1, 0, true, 0>;
66361 struct protocolIEs_t : ProtocolIE_Container<UEContextRelease_IEs>
66363 static constexpr const char* name() {return "protocolIEs_t";}
66364 using parent_t = ProtocolIE_Container<UEContextRelease_IEs>;
66367 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66368 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66369 template<typename V> void decode(V& v)
66374 template<typename V> void encode(V& v) const
66381 protocolIEs.clear();
66385 protocolIEs_t protocolIEs;
66389 X2AP-Message ::= OCTET STRING
66392 struct X2AP_Message : asn::ostring<>
66394 static constexpr const char* name() {return "X2AP-Message";}
66395 using parent_t = asn::ostring<>;
66400 X2APMessageTransfer-IEs X2AP-PROTOCOL-IES ::= {
66401 { ID id-RNL-Header CRITICALITY reject TYPE RNL-Header PRESENCE mandatory}|
66402 { ID id-x2APMessage CRITICALITY reject TYPE X2AP-Message PRESENCE optional},
66407 struct X2APMessageTransfer_IEs
66409 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66411 size_t get_index() const {return type;}
66412 bool is_unknown() const { return type == 3; }
66413 void clear() {type = 0;}
66414 void select_id_RNL_Header() { set(id_RNL_Header); type=1;}
66415 void select_id_x2APMessage() { set(id_x2APMessage); type=2;}
66416 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66417 template<typename V> bool decode(V& v)
66420 if(!v(ref_nested())) return false;
66421 if(equal(id_RNL_Header)) { type = 1; return true; }
66422 else if(equal(id_x2APMessage)) { type = 2; return true; }
66423 else { type = 3; return true;}
66427 template<typename V> bool encode(V& v) const
66429 return v(ref_nested());
66433 template<typename V> bool decode(size_t index, V& v)
66438 case 1: type = 1; if(v(ref_nested())) { return equal(id_RNL_Header);} return false;
66439 case 2: type = 2; if(v(ref_nested())) { return equal(id_x2APMessage);} return false;
66440 case 3: type = 3; return v(ref_nested());
66441 ref_nested().clear();
66446 template<typename V> bool encode(size_t index, V& v) const
66448 if(index != type) {return false;} return v(ref_nested());
66455 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66457 size_t get_index() const {return type;}
66458 bool is_unknown() const { return type == 3; }
66459 void clear() {type = 0;}
66460 void select_id_RNL_Header() { set(reject); type=1;}
66461 void select_id_x2APMessage() { set(reject); type=2;}
66462 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66463 template<typename V> bool decode(V& v)
66466 if(!v(ref_nested())) return false;
66467 if(equal(reject)) { type = 1; return true; }
66468 else if(equal(reject)) { type = 2; return true; }
66469 else { type = 3; return true;}
66473 template<typename V> bool encode(V& v) const
66475 return v(ref_nested());
66479 template<typename V> bool decode(size_t index, V& v)
66484 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66485 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
66486 case 3: type = 3; return v(ref_nested());
66487 ref_nested().clear();
66492 template<typename V> bool encode(size_t index, V& v) const
66494 if(index != type) {return false;} return v(ref_nested());
66501 struct Value_t : asn::typefield<true>
66503 ~Value_t() {clear();}
66504 size_t get_index() const {return type;}
66505 RNL_Header& select_id_RNL_Header() { return set<RNL_Header>(1); }
66506 RNL_Header const* get_id_RNL_Header() const { return get<RNL_Header>(1); }
66507 X2AP_Message& select_id_x2APMessage() { return set<X2AP_Message>(2); }
66508 X2AP_Message const* get_id_x2APMessage() const { return get<X2AP_Message>(2); }
66509 bool is_unknown() const { return type == 3; }
66514 case 1: var.destroy<RNL_Header>(); break;
66515 case 2: var.destroy<X2AP_Message>(); break;
66517 type = 0; ref_nested().clear();
66519 template<typename V> static inline void enumerate(V& v)
66521 v.template operator()<RNL_Header>(1);
66522 v.template operator()<X2AP_Message>(2);
66526 template<typename V> bool decode(size_t index, V& v)
66531 case 1: v(select_id_RNL_Header()); return true;
66532 case 2: v(select_id_x2APMessage()); return true;
66533 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
66538 template<typename V> bool encode(size_t index, V& v) const
66540 if(index != type) return false;
66543 case 1: v(var.as<RNL_Header>()); return true;
66544 case 2: v(var.as<X2AP_Message>()); return true;
66550 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66551 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66554 char dummy1[sizeof(RNL_Header)];
66555 char dummy2[sizeof(X2AP_Message)];
66558 asn::variant<sizeof(union_type)> var;
66562 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66564 size_t get_index() const {return type;}
66565 bool is_unknown() const { return type == 3; }
66566 void clear() {type = 0;}
66567 void select_id_RNL_Header() { set(mandatory); type=1;}
66568 void select_id_x2APMessage() { set(optional); type=2;}
66569 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66570 template<typename V> bool decode(V& v)
66573 if(!v(ref_nested())) return false;
66574 if(equal(mandatory)) { type = 1; return true; }
66575 else if(equal(optional)) { type = 2; return true; }
66576 else { type = 3; return true;}
66580 template<typename V> bool encode(V& v) const
66582 return v(ref_nested());
66586 template<typename V> bool decode(size_t index, V& v)
66591 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66592 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
66593 case 3: type = 3; return v(ref_nested());
66594 ref_nested().clear();
66599 template<typename V> bool encode(size_t index, V& v) const
66601 if(index != type) {return false;} return v(ref_nested());
66611 X2APMessageTransfer ::= SEQUENCE {
66612 protocolIEs ProtocolIE-Container {{X2APMessageTransfer-IEs}},
66617 struct X2APMessageTransfer : asn::sequence<1, 0, true, 0>
66619 static constexpr const char* name() {return "X2APMessageTransfer";}
66620 using parent_t = asn::sequence<1, 0, true, 0>;
66621 struct protocolIEs_t : ProtocolIE_Container<X2APMessageTransfer_IEs>
66623 static constexpr const char* name() {return "protocolIEs_t";}
66624 using parent_t = ProtocolIE_Container<X2APMessageTransfer_IEs>;
66627 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66628 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66629 template<typename V> void decode(V& v)
66634 template<typename V> void encode(V& v) const
66641 protocolIEs.clear();
66645 protocolIEs_t protocolIEs;
66649 X2Release-IEs X2AP-PROTOCOL-IES ::= {
66650 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory},
66655 struct X2Release_IEs
66657 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66659 size_t get_index() const {return type;}
66660 bool is_unknown() const { return type == 2; }
66661 void clear() {type = 0;}
66662 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
66663 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66664 template<typename V> bool decode(V& v)
66667 if(!v(ref_nested())) return false;
66668 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
66669 else { type = 2; return true;}
66673 template<typename V> bool encode(V& v) const
66675 return v(ref_nested());
66679 template<typename V> bool decode(size_t index, V& v)
66684 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
66685 case 2: type = 2; return v(ref_nested());
66686 ref_nested().clear();
66691 template<typename V> bool encode(size_t index, V& v) const
66693 if(index != type) {return false;} return v(ref_nested());
66700 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66702 size_t get_index() const {return type;}
66703 bool is_unknown() const { return type == 2; }
66704 void clear() {type = 0;}
66705 void select_id_GlobalENB_ID() { set(reject); type=1;}
66706 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66707 template<typename V> bool decode(V& v)
66710 if(!v(ref_nested())) return false;
66711 if(equal(reject)) { type = 1; return true; }
66712 else { type = 2; return true;}
66716 template<typename V> bool encode(V& v) const
66718 return v(ref_nested());
66722 template<typename V> bool decode(size_t index, V& v)
66727 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66728 case 2: type = 2; return v(ref_nested());
66729 ref_nested().clear();
66734 template<typename V> bool encode(size_t index, V& v) const
66736 if(index != type) {return false;} return v(ref_nested());
66743 struct Value_t : asn::typefield<true>
66745 ~Value_t() {clear();}
66746 size_t get_index() const {return type;}
66747 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
66748 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
66749 bool is_unknown() const { return type == 2; }
66754 case 1: var.destroy<GlobalENB_ID>(); break;
66756 type = 0; ref_nested().clear();
66758 template<typename V> static inline void enumerate(V& v)
66760 v.template operator()<GlobalENB_ID>(1);
66764 template<typename V> bool decode(size_t index, V& v)
66769 case 1: v(select_id_GlobalENB_ID()); return true;
66770 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
66775 template<typename V> bool encode(size_t index, V& v) const
66777 if(index != type) return false;
66780 case 1: v(var.as<GlobalENB_ID>()); return true;
66786 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66787 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66790 char dummy1[sizeof(GlobalENB_ID)];
66793 asn::variant<sizeof(union_type)> var;
66797 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66799 size_t get_index() const {return type;}
66800 bool is_unknown() const { return type == 2; }
66801 void clear() {type = 0;}
66802 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
66803 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66804 template<typename V> bool decode(V& v)
66807 if(!v(ref_nested())) return false;
66808 if(equal(mandatory)) { type = 1; return true; }
66809 else { type = 2; return true;}
66813 template<typename V> bool encode(V& v) const
66815 return v(ref_nested());
66819 template<typename V> bool decode(size_t index, V& v)
66824 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66825 case 2: type = 2; return v(ref_nested());
66826 ref_nested().clear();
66831 template<typename V> bool encode(size_t index, V& v) const
66833 if(index != type) {return false;} return v(ref_nested());
66843 X2Release ::= SEQUENCE {
66844 protocolIEs ProtocolIE-Container {{X2Release-IEs}},
66849 struct X2Release : asn::sequence<1, 0, true, 0>
66851 static constexpr const char* name() {return "X2Release";}
66852 using parent_t = asn::sequence<1, 0, true, 0>;
66853 struct protocolIEs_t : ProtocolIE_Container<X2Release_IEs>
66855 static constexpr const char* name() {return "protocolIEs_t";}
66856 using parent_t = ProtocolIE_Container<X2Release_IEs>;
66859 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66860 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66861 template<typename V> void decode(V& v)
66866 template<typename V> void encode(V& v) const
66873 protocolIEs.clear();
66877 protocolIEs_t protocolIEs;
66881 X2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
66882 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory}|
66883 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
66888 struct X2RemovalFailure_IEs
66890 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66892 size_t get_index() const {return type;}
66893 bool is_unknown() const { return type == 3; }
66894 void clear() {type = 0;}
66895 void select_id_Cause() { set(id_Cause); type=1;}
66896 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
66897 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66898 template<typename V> bool decode(V& v)
66901 if(!v(ref_nested())) return false;
66902 if(equal(id_Cause)) { type = 1; return true; }
66903 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
66904 else { type = 3; return true;}
66908 template<typename V> bool encode(V& v) const
66910 return v(ref_nested());
66914 template<typename V> bool decode(size_t index, V& v)
66919 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
66920 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
66921 case 3: type = 3; return v(ref_nested());
66922 ref_nested().clear();
66927 template<typename V> bool encode(size_t index, V& v) const
66929 if(index != type) {return false;} return v(ref_nested());
66936 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66938 size_t get_index() const {return type;}
66939 bool is_unknown() const { return type == 3; }
66940 void clear() {type = 0;}
66941 void select_id_Cause() { set(ignore); type=1;}
66942 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
66943 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66944 template<typename V> bool decode(V& v)
66947 if(!v(ref_nested())) return false;
66948 if(equal(ignore)) { type = 1; return true; }
66949 else if(equal(ignore)) { type = 2; return true; }
66950 else { type = 3; return true;}
66954 template<typename V> bool encode(V& v) const
66956 return v(ref_nested());
66960 template<typename V> bool decode(size_t index, V& v)
66965 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
66966 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
66967 case 3: type = 3; return v(ref_nested());
66968 ref_nested().clear();
66973 template<typename V> bool encode(size_t index, V& v) const
66975 if(index != type) {return false;} return v(ref_nested());
66982 struct Value_t : asn::typefield<true>
66984 ~Value_t() {clear();}
66985 size_t get_index() const {return type;}
66986 Cause& select_id_Cause() { return set<Cause>(1); }
66987 Cause const* get_id_Cause() const { return get<Cause>(1); }
66988 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
66989 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
66990 bool is_unknown() const { return type == 3; }
66995 case 1: var.destroy<Cause>(); break;
66996 case 2: var.destroy<CriticalityDiagnostics>(); break;
66998 type = 0; ref_nested().clear();
67000 template<typename V> static inline void enumerate(V& v)
67002 v.template operator()<Cause>(1);
67003 v.template operator()<CriticalityDiagnostics>(2);
67007 template<typename V> bool decode(size_t index, V& v)
67012 case 1: v(select_id_Cause()); return true;
67013 case 2: v(select_id_CriticalityDiagnostics()); return true;
67014 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67019 template<typename V> bool encode(size_t index, V& v) const
67021 if(index != type) return false;
67024 case 1: v(var.as<Cause>()); return true;
67025 case 2: v(var.as<CriticalityDiagnostics>()); return true;
67031 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67032 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67035 char dummy1[sizeof(Cause)];
67036 char dummy2[sizeof(CriticalityDiagnostics)];
67039 asn::variant<sizeof(union_type)> var;
67043 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67045 size_t get_index() const {return type;}
67046 bool is_unknown() const { return type == 3; }
67047 void clear() {type = 0;}
67048 void select_id_Cause() { set(mandatory); type=1;}
67049 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
67050 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67051 template<typename V> bool decode(V& v)
67054 if(!v(ref_nested())) return false;
67055 if(equal(mandatory)) { type = 1; return true; }
67056 else if(equal(optional)) { type = 2; return true; }
67057 else { type = 3; return true;}
67061 template<typename V> bool encode(V& v) const
67063 return v(ref_nested());
67067 template<typename V> bool decode(size_t index, V& v)
67072 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67073 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67074 case 3: type = 3; return v(ref_nested());
67075 ref_nested().clear();
67080 template<typename V> bool encode(size_t index, V& v) const
67082 if(index != type) {return false;} return v(ref_nested());
67092 X2RemovalFailure ::= SEQUENCE {
67093 protocolIEs ProtocolIE-Container {{X2RemovalFailure-IEs}},
67098 struct X2RemovalFailure : asn::sequence<1, 0, true, 0>
67100 static constexpr const char* name() {return "X2RemovalFailure";}
67101 using parent_t = asn::sequence<1, 0, true, 0>;
67102 struct protocolIEs_t : ProtocolIE_Container<X2RemovalFailure_IEs>
67104 static constexpr const char* name() {return "protocolIEs_t";}
67105 using parent_t = ProtocolIE_Container<X2RemovalFailure_IEs>;
67108 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67109 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67110 template<typename V> void decode(V& v)
67115 template<typename V> void encode(V& v) const
67122 protocolIEs.clear();
67126 protocolIEs_t protocolIEs;
67130 X2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
67131 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
67132 { ID id-X2RemovalThreshold CRITICALITY reject TYPE X2BenefitValue PRESENCE optional},
67137 struct X2RemovalRequest_IEs
67139 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67141 size_t get_index() const {return type;}
67142 bool is_unknown() const { return type == 3; }
67143 void clear() {type = 0;}
67144 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67145 void select_id_X2RemovalThreshold() { set(id_X2RemovalThreshold); type=2;}
67146 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67147 template<typename V> bool decode(V& v)
67150 if(!v(ref_nested())) return false;
67151 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67152 else if(equal(id_X2RemovalThreshold)) { type = 2; return true; }
67153 else { type = 3; return true;}
67157 template<typename V> bool encode(V& v) const
67159 return v(ref_nested());
67163 template<typename V> bool decode(size_t index, V& v)
67168 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67169 case 2: type = 2; if(v(ref_nested())) { return equal(id_X2RemovalThreshold);} return false;
67170 case 3: type = 3; return v(ref_nested());
67171 ref_nested().clear();
67176 template<typename V> bool encode(size_t index, V& v) const
67178 if(index != type) {return false;} return v(ref_nested());
67185 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67187 size_t get_index() const {return type;}
67188 bool is_unknown() const { return type == 3; }
67189 void clear() {type = 0;}
67190 void select_id_GlobalENB_ID() { set(reject); type=1;}
67191 void select_id_X2RemovalThreshold() { set(reject); type=2;}
67192 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67193 template<typename V> bool decode(V& v)
67196 if(!v(ref_nested())) return false;
67197 if(equal(reject)) { type = 1; return true; }
67198 else if(equal(reject)) { type = 2; return true; }
67199 else { type = 3; return true;}
67203 template<typename V> bool encode(V& v) const
67205 return v(ref_nested());
67209 template<typename V> bool decode(size_t index, V& v)
67214 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67215 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
67216 case 3: type = 3; return v(ref_nested());
67217 ref_nested().clear();
67222 template<typename V> bool encode(size_t index, V& v) const
67224 if(index != type) {return false;} return v(ref_nested());
67231 struct Value_t : asn::typefield<true>
67233 ~Value_t() {clear();}
67234 size_t get_index() const {return type;}
67235 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
67236 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
67237 X2BenefitValue& select_id_X2RemovalThreshold() { return set<X2BenefitValue>(2); }
67238 X2BenefitValue const* get_id_X2RemovalThreshold() const { return get<X2BenefitValue>(2); }
67239 bool is_unknown() const { return type == 3; }
67244 case 1: var.destroy<GlobalENB_ID>(); break;
67245 case 2: var.destroy<X2BenefitValue>(); break;
67247 type = 0; ref_nested().clear();
67249 template<typename V> static inline void enumerate(V& v)
67251 v.template operator()<GlobalENB_ID>(1);
67252 v.template operator()<X2BenefitValue>(2);
67256 template<typename V> bool decode(size_t index, V& v)
67261 case 1: v(select_id_GlobalENB_ID()); return true;
67262 case 2: v(select_id_X2RemovalThreshold()); return true;
67263 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67268 template<typename V> bool encode(size_t index, V& v) const
67270 if(index != type) return false;
67273 case 1: v(var.as<GlobalENB_ID>()); return true;
67274 case 2: v(var.as<X2BenefitValue>()); return true;
67280 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67281 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67284 char dummy1[sizeof(GlobalENB_ID)];
67285 char dummy2[sizeof(X2BenefitValue)];
67288 asn::variant<sizeof(union_type)> var;
67292 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67294 size_t get_index() const {return type;}
67295 bool is_unknown() const { return type == 3; }
67296 void clear() {type = 0;}
67297 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
67298 void select_id_X2RemovalThreshold() { set(optional); type=2;}
67299 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67300 template<typename V> bool decode(V& v)
67303 if(!v(ref_nested())) return false;
67304 if(equal(mandatory)) { type = 1; return true; }
67305 else if(equal(optional)) { type = 2; return true; }
67306 else { type = 3; return true;}
67310 template<typename V> bool encode(V& v) const
67312 return v(ref_nested());
67316 template<typename V> bool decode(size_t index, V& v)
67321 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67322 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67323 case 3: type = 3; return v(ref_nested());
67324 ref_nested().clear();
67329 template<typename V> bool encode(size_t index, V& v) const
67331 if(index != type) {return false;} return v(ref_nested());
67341 X2RemovalRequest ::= SEQUENCE {
67342 protocolIEs ProtocolIE-Container {{X2RemovalRequest-IEs}},
67347 struct X2RemovalRequest : asn::sequence<1, 0, true, 0>
67349 static constexpr const char* name() {return "X2RemovalRequest";}
67350 using parent_t = asn::sequence<1, 0, true, 0>;
67351 struct protocolIEs_t : ProtocolIE_Container<X2RemovalRequest_IEs>
67353 static constexpr const char* name() {return "protocolIEs_t";}
67354 using parent_t = ProtocolIE_Container<X2RemovalRequest_IEs>;
67357 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67358 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67359 template<typename V> void decode(V& v)
67364 template<typename V> void encode(V& v) const
67371 protocolIEs.clear();
67375 protocolIEs_t protocolIEs;
67379 X2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
67380 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
67381 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional},
67386 struct X2RemovalResponse_IEs
67388 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67390 size_t get_index() const {return type;}
67391 bool is_unknown() const { return type == 3; }
67392 void clear() {type = 0;}
67393 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67394 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
67395 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67396 template<typename V> bool decode(V& v)
67399 if(!v(ref_nested())) return false;
67400 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67401 else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
67402 else { type = 3; return true;}
67406 template<typename V> bool encode(V& v) const
67408 return v(ref_nested());
67412 template<typename V> bool decode(size_t index, V& v)
67417 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67418 case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
67419 case 3: type = 3; return v(ref_nested());
67420 ref_nested().clear();
67425 template<typename V> bool encode(size_t index, V& v) const
67427 if(index != type) {return false;} return v(ref_nested());
67434 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67436 size_t get_index() const {return type;}
67437 bool is_unknown() const { return type == 3; }
67438 void clear() {type = 0;}
67439 void select_id_GlobalENB_ID() { set(reject); type=1;}
67440 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
67441 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67442 template<typename V> bool decode(V& v)
67445 if(!v(ref_nested())) return false;
67446 if(equal(reject)) { type = 1; return true; }
67447 else if(equal(ignore)) { type = 2; return true; }
67448 else { type = 3; return true;}
67452 template<typename V> bool encode(V& v) const
67454 return v(ref_nested());
67458 template<typename V> bool decode(size_t index, V& v)
67463 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67464 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
67465 case 3: type = 3; return v(ref_nested());
67466 ref_nested().clear();
67471 template<typename V> bool encode(size_t index, V& v) const
67473 if(index != type) {return false;} return v(ref_nested());
67480 struct Value_t : asn::typefield<true>
67482 ~Value_t() {clear();}
67483 size_t get_index() const {return type;}
67484 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
67485 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
67486 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
67487 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
67488 bool is_unknown() const { return type == 3; }
67493 case 1: var.destroy<GlobalENB_ID>(); break;
67494 case 2: var.destroy<CriticalityDiagnostics>(); break;
67496 type = 0; ref_nested().clear();
67498 template<typename V> static inline void enumerate(V& v)
67500 v.template operator()<GlobalENB_ID>(1);
67501 v.template operator()<CriticalityDiagnostics>(2);
67505 template<typename V> bool decode(size_t index, V& v)
67510 case 1: v(select_id_GlobalENB_ID()); return true;
67511 case 2: v(select_id_CriticalityDiagnostics()); return true;
67512 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67517 template<typename V> bool encode(size_t index, V& v) const
67519 if(index != type) return false;
67522 case 1: v(var.as<GlobalENB_ID>()); return true;
67523 case 2: v(var.as<CriticalityDiagnostics>()); return true;
67529 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67530 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67533 char dummy1[sizeof(CriticalityDiagnostics)];
67534 char dummy2[sizeof(GlobalENB_ID)];
67537 asn::variant<sizeof(union_type)> var;
67541 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67543 size_t get_index() const {return type;}
67544 bool is_unknown() const { return type == 3; }
67545 void clear() {type = 0;}
67546 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
67547 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
67548 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67549 template<typename V> bool decode(V& v)
67552 if(!v(ref_nested())) return false;
67553 if(equal(mandatory)) { type = 1; return true; }
67554 else if(equal(optional)) { type = 2; return true; }
67555 else { type = 3; return true;}
67559 template<typename V> bool encode(V& v) const
67561 return v(ref_nested());
67565 template<typename V> bool decode(size_t index, V& v)
67570 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67571 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67572 case 3: type = 3; return v(ref_nested());
67573 ref_nested().clear();
67578 template<typename V> bool encode(size_t index, V& v) const
67580 if(index != type) {return false;} return v(ref_nested());
67590 X2RemovalResponse ::= SEQUENCE {
67591 protocolIEs ProtocolIE-Container {{X2RemovalResponse-IEs}},
67596 struct X2RemovalResponse : asn::sequence<1, 0, true, 0>
67598 static constexpr const char* name() {return "X2RemovalResponse";}
67599 using parent_t = asn::sequence<1, 0, true, 0>;
67600 struct protocolIEs_t : ProtocolIE_Container<X2RemovalResponse_IEs>
67602 static constexpr const char* name() {return "protocolIEs_t";}
67603 using parent_t = ProtocolIE_Container<X2RemovalResponse_IEs>;
67606 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67607 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67608 template<typename V> void decode(V& v)
67613 template<typename V> void encode(V& v) const
67620 protocolIEs.clear();
67624 protocolIEs_t protocolIEs;
67628 X2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
67629 { ID id-Cause CRITICALITY ignore TYPE Cause PRESENCE mandatory} |
67630 { ID id-TimeToWait CRITICALITY ignore TYPE TimeToWait PRESENCE optional} |
67631 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional },
67637 struct X2SetupFailure_IEs
67639 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67641 size_t get_index() const {return type;}
67642 bool is_unknown() const { return type == 4; }
67643 void clear() {type = 0;}
67644 void select_id_Cause() { set(id_Cause); type=1;}
67645 void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
67646 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
67647 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67648 template<typename V> bool decode(V& v)
67651 if(!v(ref_nested())) return false;
67652 if(equal(id_Cause)) { type = 1; return true; }
67653 else if(equal(id_TimeToWait)) { type = 2; return true; }
67654 else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
67655 else { type = 4; return true;}
67659 template<typename V> bool encode(V& v) const
67661 return v(ref_nested());
67665 template<typename V> bool decode(size_t index, V& v)
67670 case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
67671 case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
67672 case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
67673 case 4: type = 4; return v(ref_nested());
67674 ref_nested().clear();
67679 template<typename V> bool encode(size_t index, V& v) const
67681 if(index != type) {return false;} return v(ref_nested());
67688 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67690 size_t get_index() const {return type;}
67691 bool is_unknown() const { return type == 4; }
67692 void clear() {type = 0;}
67693 void select_id_Cause() { set(ignore); type=1;}
67694 void select_id_TimeToWait() { set(ignore); type=2;}
67695 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
67696 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67697 template<typename V> bool decode(V& v)
67700 if(!v(ref_nested())) return false;
67701 if(equal(ignore)) { type = 1; return true; }
67702 else if(equal(ignore)) { type = 2; return true; }
67703 else if(equal(ignore)) { type = 3; return true; }
67704 else { type = 4; return true;}
67708 template<typename V> bool encode(V& v) const
67710 return v(ref_nested());
67714 template<typename V> bool decode(size_t index, V& v)
67719 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
67720 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
67721 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
67722 case 4: type = 4; return v(ref_nested());
67723 ref_nested().clear();
67728 template<typename V> bool encode(size_t index, V& v) const
67730 if(index != type) {return false;} return v(ref_nested());
67737 struct Value_t : asn::typefield<true>
67739 ~Value_t() {clear();}
67740 size_t get_index() const {return type;}
67741 Cause& select_id_Cause() { return set<Cause>(1); }
67742 Cause const* get_id_Cause() const { return get<Cause>(1); }
67743 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
67744 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
67745 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
67746 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
67747 bool is_unknown() const { return type == 4; }
67752 case 1: var.destroy<Cause>(); break;
67753 case 2: var.destroy<TimeToWait>(); break;
67754 case 3: var.destroy<CriticalityDiagnostics>(); break;
67756 type = 0; ref_nested().clear();
67758 template<typename V> static inline void enumerate(V& v)
67760 v.template operator()<Cause>(1);
67761 v.template operator()<TimeToWait>(2);
67762 v.template operator()<CriticalityDiagnostics>(3);
67766 template<typename V> bool decode(size_t index, V& v)
67771 case 1: v(select_id_Cause()); return true;
67772 case 2: v(select_id_TimeToWait()); return true;
67773 case 3: v(select_id_CriticalityDiagnostics()); return true;
67774 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
67779 template<typename V> bool encode(size_t index, V& v) const
67781 if(index != type) return false;
67784 case 1: v(var.as<Cause>()); return true;
67785 case 2: v(var.as<TimeToWait>()); return true;
67786 case 3: v(var.as<CriticalityDiagnostics>()); return true;
67792 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67793 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67796 char dummy1[sizeof(Cause)];
67797 char dummy2[sizeof(CriticalityDiagnostics)];
67798 char dummy3[sizeof(TimeToWait)];
67801 asn::variant<sizeof(union_type)> var;
67805 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67807 size_t get_index() const {return type;}
67808 bool is_unknown() const { return type == 4; }
67809 void clear() {type = 0;}
67810 void select_id_Cause() { set(mandatory); type=1;}
67811 void select_id_TimeToWait() { set(optional); type=2;}
67812 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
67813 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67814 template<typename V> bool decode(V& v)
67817 if(!v(ref_nested())) return false;
67818 if(equal(mandatory)) { type = 1; return true; }
67819 else if(equal(optional)) { type = 2; return true; }
67820 else if(equal(optional)) { type = 3; return true; }
67821 else { type = 4; return true;}
67825 template<typename V> bool encode(V& v) const
67827 return v(ref_nested());
67831 template<typename V> bool decode(size_t index, V& v)
67836 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67837 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67838 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
67839 case 4: type = 4; return v(ref_nested());
67840 ref_nested().clear();
67845 template<typename V> bool encode(size_t index, V& v) const
67847 if(index != type) {return false;} return v(ref_nested());
67857 X2SetupFailure ::= SEQUENCE {
67858 protocolIEs ProtocolIE-Container {{X2SetupFailure-IEs}},
67863 struct X2SetupFailure : asn::sequence<1, 0, true, 0>
67865 static constexpr const char* name() {return "X2SetupFailure";}
67866 using parent_t = asn::sequence<1, 0, true, 0>;
67867 struct protocolIEs_t : ProtocolIE_Container<X2SetupFailure_IEs>
67869 static constexpr const char* name() {return "protocolIEs_t";}
67870 using parent_t = ProtocolIE_Container<X2SetupFailure_IEs>;
67873 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67874 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67875 template<typename V> void decode(V& v)
67880 template<typename V> void encode(V& v) const
67887 protocolIEs.clear();
67891 protocolIEs_t protocolIEs;
67895 X2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
67896 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
67897 { ID id-ServedCells CRITICALITY reject TYPE ServedCells PRESENCE mandatory}|
67898 { ID id-GUGroupIDList CRITICALITY reject TYPE GUGroupIDList PRESENCE optional}|
67899 { ID id-LHN-ID CRITICALITY ignore TYPE LHN-ID PRESENCE optional},
67904 struct X2SetupRequest_IEs
67906 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67908 size_t get_index() const {return type;}
67909 bool is_unknown() const { return type == 5; }
67910 void clear() {type = 0;}
67911 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67912 void select_id_ServedCells() { set(id_ServedCells); type=2;}
67913 void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
67914 void select_id_LHN_ID() { set(id_LHN_ID); type=4;}
67915 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67916 template<typename V> bool decode(V& v)
67919 if(!v(ref_nested())) return false;
67920 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67921 else if(equal(id_ServedCells)) { type = 2; return true; }
67922 else if(equal(id_GUGroupIDList)) { type = 3; return true; }
67923 else if(equal(id_LHN_ID)) { type = 4; return true; }
67924 else { type = 5; return true;}
67928 template<typename V> bool encode(V& v) const
67930 return v(ref_nested());
67934 template<typename V> bool decode(size_t index, V& v)
67939 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67940 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
67941 case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
67942 case 4: type = 4; if(v(ref_nested())) { return equal(id_LHN_ID);} return false;
67943 case 5: type = 5; return v(ref_nested());
67944 ref_nested().clear();
67949 template<typename V> bool encode(size_t index, V& v) const
67951 if(index != type) {return false;} return v(ref_nested());
67958 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67960 size_t get_index() const {return type;}
67961 bool is_unknown() const { return type == 5; }
67962 void clear() {type = 0;}
67963 void select_id_GlobalENB_ID() { set(reject); type=1;}
67964 void select_id_ServedCells() { set(reject); type=2;}
67965 void select_id_GUGroupIDList() { set(reject); type=3;}
67966 void select_id_LHN_ID() { set(ignore); type=4;}
67967 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67968 template<typename V> bool decode(V& v)
67971 if(!v(ref_nested())) return false;
67972 if(equal(reject)) { type = 1; return true; }
67973 else if(equal(reject)) { type = 2; return true; }
67974 else if(equal(reject)) { type = 3; return true; }
67975 else if(equal(ignore)) { type = 4; return true; }
67976 else { type = 5; return true;}
67980 template<typename V> bool encode(V& v) const
67982 return v(ref_nested());
67986 template<typename V> bool decode(size_t index, V& v)
67991 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67992 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
67993 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
67994 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
67995 case 5: type = 5; return v(ref_nested());
67996 ref_nested().clear();
68001 template<typename V> bool encode(size_t index, V& v) const
68003 if(index != type) {return false;} return v(ref_nested());
68010 struct Value_t : asn::typefield<true>
68012 ~Value_t() {clear();}
68013 size_t get_index() const {return type;}
68014 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
68015 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
68016 ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
68017 ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
68018 GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
68019 GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
68020 LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(4); }
68021 LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(4); }
68022 bool is_unknown() const { return type == 5; }
68027 case 1: var.destroy<GlobalENB_ID>(); break;
68028 case 2: var.destroy<ServedCells>(); break;
68029 case 3: var.destroy<GUGroupIDList>(); break;
68030 case 4: var.destroy<LHN_ID>(); break;
68032 type = 0; ref_nested().clear();
68034 template<typename V> static inline void enumerate(V& v)
68036 v.template operator()<GlobalENB_ID>(1);
68037 v.template operator()<ServedCells>(2);
68038 v.template operator()<GUGroupIDList>(3);
68039 v.template operator()<LHN_ID>(4);
68043 template<typename V> bool decode(size_t index, V& v)
68048 case 1: v(select_id_GlobalENB_ID()); return true;
68049 case 2: v(select_id_ServedCells()); return true;
68050 case 3: v(select_id_GUGroupIDList()); return true;
68051 case 4: v(select_id_LHN_ID()); return true;
68052 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
68057 template<typename V> bool encode(size_t index, V& v) const
68059 if(index != type) return false;
68062 case 1: v(var.as<GlobalENB_ID>()); return true;
68063 case 2: v(var.as<ServedCells>()); return true;
68064 case 3: v(var.as<GUGroupIDList>()); return true;
68065 case 4: v(var.as<LHN_ID>()); return true;
68071 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
68072 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
68075 char dummy1[sizeof(GUGroupIDList)];
68076 char dummy2[sizeof(GlobalENB_ID)];
68077 char dummy3[sizeof(LHN_ID)];
68078 char dummy4[sizeof(ServedCells)];
68081 asn::variant<sizeof(union_type)> var;
68085 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
68087 size_t get_index() const {return type;}
68088 bool is_unknown() const { return type == 5; }
68089 void clear() {type = 0;}
68090 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
68091 void select_id_ServedCells() { set(mandatory); type=2;}
68092 void select_id_GUGroupIDList() { set(optional); type=3;}
68093 void select_id_LHN_ID() { set(optional); type=4;}
68094 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
68095 template<typename V> bool decode(V& v)
68098 if(!v(ref_nested())) return false;
68099 if(equal(mandatory)) { type = 1; return true; }
68100 else if(equal(mandatory)) { type = 2; return true; }
68101 else if(equal(optional)) { type = 3; return true; }
68102 else if(equal(optional)) { type = 4; return true; }
68103 else { type = 5; return true;}
68107 template<typename V> bool encode(V& v) const
68109 return v(ref_nested());
68113 template<typename V> bool decode(size_t index, V& v)
68118 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
68119 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
68120 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
68121 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
68122 case 5: type = 5; return v(ref_nested());
68123 ref_nested().clear();
68128 template<typename V> bool encode(size_t index, V& v) const
68130 if(index != type) {return false;} return v(ref_nested());
68140 X2SetupRequest ::= SEQUENCE {
68141 protocolIEs ProtocolIE-Container {{X2SetupRequest-IEs}},
68146 struct X2SetupRequest : asn::sequence<1, 0, true, 0>
68148 static constexpr const char* name() {return "X2SetupRequest";}
68149 using parent_t = asn::sequence<1, 0, true, 0>;
68150 struct protocolIEs_t : ProtocolIE_Container<X2SetupRequest_IEs>
68152 static constexpr const char* name() {return "protocolIEs_t";}
68153 using parent_t = ProtocolIE_Container<X2SetupRequest_IEs>;
68156 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
68157 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
68158 template<typename V> void decode(V& v)
68163 template<typename V> void encode(V& v) const
68170 protocolIEs.clear();
68174 protocolIEs_t protocolIEs;
68178 X2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
68179 { ID id-GlobalENB-ID CRITICALITY reject TYPE GlobalENB-ID PRESENCE mandatory}|
68180 { ID id-ServedCells CRITICALITY reject TYPE ServedCells PRESENCE mandatory}|
68181 { ID id-GUGroupIDList CRITICALITY reject TYPE GUGroupIDList PRESENCE optional}|
68182 { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}|
68183 { ID id-LHN-ID CRITICALITY ignore TYPE LHN-ID PRESENCE optional},
68188 struct X2SetupResponse_IEs
68190 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
68192 size_t get_index() const {return type;}
68193 bool is_unknown() const { return type == 6; }
68194 void clear() {type = 0;}
68195 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
68196 void select_id_ServedCells() { set(id_ServedCells); type=2;}
68197 void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
68198 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
68199 void select_id_LHN_ID() { set(id_LHN_ID); type=5;}
68200 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
68201 template<typename V> bool decode(V& v)
68204 if(!v(ref_nested())) return false;
68205 if(equal(id_GlobalENB_ID)) { type = 1; return true; }
68206 else if(equal(id_ServedCells)) { type = 2; return true; }
68207 else if(equal(id_GUGroupIDList)) { type = 3; return true; }
68208 else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
68209 else if(equal(id_LHN_ID)) { type = 5; return true; }
68210 else { type = 6; return true;}
68214 template<typename V> bool encode(V& v) const
68216 return v(ref_nested());
68220 template<typename V> bool decode(size_t index, V& v)
68225 case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
68226 case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
68227 case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
68228 case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
68229 case 5: type = 5; if(v(ref_nested())) { return equal(id_LHN_ID);} return false;
68230 case 6: type = 6; return v(ref_nested());
68231 ref_nested().clear();
68236 template<typename V> bool encode(size_t index, V& v) const
68238 if(index != type) {return false;} return v(ref_nested());
68245 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
68247 size_t get_index() const {return type;}
68248 bool is_unknown() const { return type == 6; }
68249 void clear() {type = 0;}
68250 void select_id_GlobalENB_ID() { set(reject); type=1;}
68251 void select_id_ServedCells() { set(reject); type=2;}
68252 void select_id_GUGroupIDList() { set(reject); type=3;}
68253 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
68254 void select_id_LHN_ID() { set(ignore); type=5;}
68255 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
68256 template<typename V> bool decode(V& v)
68259 if(!v(ref_nested())) return false;
68260 if(equal(reject)) { type = 1; return true; }
68261 else if(equal(reject)) { type = 2; return true; }
68262 else if(equal(reject)) { type = 3; return true; }
68263 else if(equal(ignore)) { type = 4; return true; }
68264 else if(equal(ignore)) { type = 5; return true; }
68265 else { type = 6; return true;}
68269 template<typename V> bool encode(V& v) const
68271 return v(ref_nested());
68275 template<typename V> bool decode(size_t index, V& v)
68280 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
68281 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
68282 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
68283 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
68284 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
68285 case 6: type = 6; return v(ref_nested());
68286 ref_nested().clear();
68291 template<typename V> bool encode(size_t index, V& v) const
68293 if(index != type) {return false;} return v(ref_nested());
68300 struct Value_t : asn::typefield<true>
68302 ~Value_t() {clear();}
68303 size_t get_index() const {return type;}
68304 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
68305 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
68306 ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
68307 ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
68308 GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
68309 GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
68310 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
68311 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
68312 LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(5); }
68313 LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(5); }
68314 bool is_unknown() const { return type == 6; }
68319 case 1: var.destroy<GlobalENB_ID>(); break;
68320 case 2: var.destroy<ServedCells>(); break;
68321 case 3: var.destroy<GUGroupIDList>(); break;
68322 case 4: var.destroy<CriticalityDiagnostics>(); break;
68323 case 5: var.destroy<LHN_ID>(); break;
68325 type = 0; ref_nested().clear();
68327 template<typename V> static inline void enumerate(V& v)
68329 v.template operator()<GlobalENB_ID>(1);
68330 v.template operator()<ServedCells>(2);
68331 v.template operator()<GUGroupIDList>(3);
68332 v.template operator()<CriticalityDiagnostics>(4);
68333 v.template operator()<LHN_ID>(5);
68337 template<typename V> bool decode(size_t index, V& v)
68342 case 1: v(select_id_GlobalENB_ID()); return true;
68343 case 2: v(select_id_ServedCells()); return true;
68344 case 3: v(select_id_GUGroupIDList()); return true;
68345 case 4: v(select_id_CriticalityDiagnostics()); return true;
68346 case 5: v(select_id_LHN_ID()); return true;
68347 case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
68352 template<typename V> bool encode(size_t index, V& v) const
68354 if(index != type) return false;
68357 case 1: v(var.as<GlobalENB_ID>()); return true;
68358 case 2: v(var.as<ServedCells>()); return true;
68359 case 3: v(var.as<GUGroupIDList>()); return true;
68360 case 4: v(var.as<CriticalityDiagnostics>()); return true;
68361 case 5: v(var.as<LHN_ID>()); return true;
68367 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
68368 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
68371 char dummy1[sizeof(CriticalityDiagnostics)];
68372 char dummy2[sizeof(GUGroupIDList)];
68373 char dummy3[sizeof(GlobalENB_ID)];
68374 char dummy4[sizeof(LHN_ID)];
68375 char dummy5[sizeof(ServedCells)];
68378 asn::variant<sizeof(union_type)> var;
68382 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
68384 size_t get_index() const {return type;}
68385 bool is_unknown() const { return type == 6; }
68386 void clear() {type = 0;}
68387 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
68388 void select_id_ServedCells() { set(mandatory); type=2;}
68389 void select_id_GUGroupIDList() { set(optional); type=3;}
68390 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
68391 void select_id_LHN_ID() { set(optional); type=5;}
68392 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
68393 template<typename V> bool decode(V& v)
68396 if(!v(ref_nested())) return false;
68397 if(equal(mandatory)) { type = 1; return true; }
68398 else if(equal(mandatory)) { type = 2; return true; }
68399 else if(equal(optional)) { type = 3; return true; }
68400 else if(equal(optional)) { type = 4; return true; }
68401 else if(equal(optional)) { type = 5; return true; }
68402 else { type = 6; return true;}
68406 template<typename V> bool encode(V& v) const
68408 return v(ref_nested());
68412 template<typename V> bool decode(size_t index, V& v)
68417 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
68418 case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
68419 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
68420 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
68421 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
68422 case 6: type = 6; return v(ref_nested());
68423 ref_nested().clear();
68428 template<typename V> bool encode(size_t index, V& v) const
68430 if(index != type) {return false;} return v(ref_nested());
68440 X2SetupResponse ::= SEQUENCE {
68441 protocolIEs ProtocolIE-Container {{X2SetupResponse-IEs}},
68446 struct X2SetupResponse : asn::sequence<1, 0, true, 0>
68448 static constexpr const char* name() {return "X2SetupResponse";}
68449 using parent_t = asn::sequence<1, 0, true, 0>;
68450 struct protocolIEs_t : ProtocolIE_Container<X2SetupResponse_IEs>
68452 static constexpr const char* name() {return "protocolIEs_t";}
68453 using parent_t = ProtocolIE_Container<X2SetupResponse_IEs>;
68456 protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
68457 protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
68458 template<typename V> void decode(V& v)
68463 template<typename V> void encode(V& v) const
68470 protocolIEs.clear();
68474 protocolIEs_t protocolIEs;