X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=sim%2Fe2-interface.git;a=blobdiff_plain;f=e2sim%2Fe2apv1sim%2Fsrc%2FASN1%2Fgenerated%2FE2AP-PDU-Contents.hpp;fp=e2sim%2Fe2apv1sim%2Fsrc%2FASN1%2Fgenerated%2FE2AP-PDU-Contents.hpp;h=e2073d113e6c02991a983aeac20aa12bcf23a1cd;hp=0000000000000000000000000000000000000000;hb=0eba05c4ff0c99974d3f3a63b65cbe2adb209e51;hpb=c380e183231711cf9f8bc72d0eb52e532dd07085 diff --git a/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Contents.hpp b/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Contents.hpp new file mode 100644 index 0000000..e2073d1 --- /dev/null +++ b/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Contents.hpp @@ -0,0 +1,5512 @@ +/***************************************************************************** +# Copyright 2019 AT&T Intellectual Property * +# * +# Licensed under the Apache License, Version 2.0 (the "License"); * +# you may not use this file except in compliance with the License. * +# You may obtain a copy of the License at * +# * +# http://www.apache.org/licenses/LICENSE-2.0 * +# * +# Unless required by applicable law or agreed to in writing, software * +# distributed under the License is distributed on an "AS IS" BASIS, * +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * +# See the License for the specific language governing permissions and * +# limitations under the License. * +# * +******************************************************************************/ + +#pragma once + +#include "asn/asn.hpp" +static_assert(ASN_API_VERSION_MAJOR == 5, "re-generate the ASN parser's code using 'make regen-asn' (do not use -j option)"); + +#include "E2AP-IEs.hpp" +#include "X2AP-IEs.hpp" +#include "X2AP-Constants.hpp" +#include "X2AP-Containers.hpp" +#include "E2AP-Constants.hpp" + +/* +RANfunction-Item ::= SEQUENCE { + ranFunctionID RANfunctionID, + ranFunctionDefinition RANfunctionDefinition, + ... +} +*/ + +struct RANfunction_Item : asn::sequence<2, 0, true, 0> +{ + static constexpr const char* name() {return "RANfunction-Item";} + using parent_t = asn::sequence<2, 0, true, 0>; + struct ranFunctionID_t : RANfunctionID + { + static constexpr const char* name() {return "ranFunctionID_t";} + using parent_t = RANfunctionID; + + }; + ranFunctionID_t& ref_ranFunctionID() {return ranFunctionID;} + ranFunctionID_t const& ref_ranFunctionID() const {return ranFunctionID;} + struct ranFunctionDefinition_t : RANfunctionDefinition + { + static constexpr const char* name() {return "ranFunctionDefinition_t";} + using parent_t = RANfunctionDefinition; + + }; + ranFunctionDefinition_t& ref_ranFunctionDefinition() {return ranFunctionDefinition;} + ranFunctionDefinition_t const& ref_ranFunctionDefinition() const {return ranFunctionDefinition;} + template void decode(V& v) + { + v(ranFunctionID); + v(ranFunctionDefinition); + + }; + template void encode(V& v) const + { + v(ranFunctionID); + v(ranFunctionDefinition); + + }; + void clear() + { + ranFunctionID.clear(); + ranFunctionDefinition.clear(); + + }; + private: + ranFunctionID_t ranFunctionID; + ranFunctionDefinition_t ranFunctionDefinition; + +}; +/* +RANfunction-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunction-Item CRITICALITY ignore TYPE RANfunction-Item PRESENCE mandatory }, + ... +} +*/ + +struct RANfunction_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunction_Item() { set(id_RANfunction_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunction_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunction_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunction_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunction_Item& select_id_RANfunction_Item() { return set(1); } + RANfunction_Item const* get_id_RANfunction_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunction_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunction_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunction_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RANfunctionID-Item ::= SEQUENCE { + ranFunctionID RANfunctionID, + ... +} +*/ + +struct RANfunctionID_Item : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RANfunctionID-Item";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct ranFunctionID_t : RANfunctionID + { + static constexpr const char* name() {return "ranFunctionID_t";} + using parent_t = RANfunctionID; + + }; + ranFunctionID_t& ref_ranFunctionID() {return ranFunctionID;} + ranFunctionID_t const& ref_ranFunctionID() const {return ranFunctionID;} + template void decode(V& v) + { + v(ranFunctionID); + + }; + template void encode(V& v) const + { + v(ranFunctionID); + + }; + void clear() + { + ranFunctionID.clear(); + + }; + private: + ranFunctionID_t ranFunctionID; + +}; +/* +RANfunctionID-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionID-Item CRITICALITY ignore TYPE RANfunctionID-Item PRESENCE mandatory }, + ... +} +*/ + +struct RANfunctionID_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionID_Item() { set(id_RANfunctionID_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionID_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionID_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionID_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctionID_Item& select_id_RANfunctionID_Item() { return set(1); } + RANfunctionID_Item const* get_id_RANfunctionID_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionID_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionID_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RANfunctionIDcause-Item ::= SEQUENCE { + ranFunctionID RANfunctionID, + ricCause RICcause, + ... +} +*/ + +struct RANfunctionIDcause_Item : asn::sequence<2, 0, true, 0> +{ + static constexpr const char* name() {return "RANfunctionIDcause-Item";} + using parent_t = asn::sequence<2, 0, true, 0>; + struct ranFunctionID_t : RANfunctionID + { + static constexpr const char* name() {return "ranFunctionID_t";} + using parent_t = RANfunctionID; + + }; + ranFunctionID_t& ref_ranFunctionID() {return ranFunctionID;} + ranFunctionID_t const& ref_ranFunctionID() const {return ranFunctionID;} + struct ricCause_t : RICcause + { + static constexpr const char* name() {return "ricCause_t";} + using parent_t = RICcause; + + }; + ricCause_t& ref_ricCause() {return ricCause;} + ricCause_t const& ref_ricCause() const {return ricCause;} + template void decode(V& v) + { + v(ranFunctionID); + v(ricCause); + + }; + template void encode(V& v) const + { + v(ranFunctionID); + v(ricCause); + + }; + void clear() + { + ranFunctionID.clear(); + ricCause.clear(); + + }; + private: + ranFunctionID_t ranFunctionID; + ricCause_t ricCause; + +}; +/* +RANfunctionIDcause-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionIEcause-Item CRITICALITY ignore TYPE RANfunctionIDcause-Item PRESENCE mandatory }, + ... +} +*/ + +struct RANfunctionIDcause_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionIEcause_Item() { set(id_RANfunctionIEcause_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionIEcause_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionIEcause_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionIEcause_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctionIDcause_Item& select_id_RANfunctionIEcause_Item() { return set(1); } + RANfunctionIDcause_Item const* get_id_RANfunctionIEcause_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionIEcause_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionIDcause_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionIEcause_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RANfunctions-List ::= SEQUENCE (SIZE(0..maxofRANfunctionID)) OF ProtocolIE-Single-Container { {RANfunction-ItemIEs} } +*/ + +struct RANfunctions_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RANfunctions_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RANfunctions_List : asn::sequenceof +{ + static constexpr const char* name() {return "RANfunctions-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RANfunctionsID-List ::= SEQUENCE (SIZE(0..maxofRANfunctionID)) OF ProtocolIE-Single-Container{{RANfunctionID-ItemIEs}} +*/ + +struct RANfunctionsID_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RANfunctionsID_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RANfunctionsID_List : asn::sequenceof +{ + static constexpr const char* name() {return "RANfunctionsID-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RANfunctionsIDcause-List ::= SEQUENCE (SIZE(0..maxofRANfunctionID)) OF ProtocolIE-Single-Container { {RANfunctionIDcause-ItemIEs} } +*/ + +struct RANfunctionsIDcause_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RANfunctionsIDcause_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RANfunctionsIDcause_List : asn::sequenceof +{ + static constexpr const char* name() {return "RANfunctionsIDcause-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RICaction-Admitted-Item ::= SEQUENCE { + ricActionID RICactionID, + ... +} +*/ + +struct RICaction_Admitted_Item : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICaction-Admitted-Item";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct ricActionID_t : RICactionID + { + static constexpr const char* name() {return "ricActionID_t";} + using parent_t = RICactionID; + + }; + ricActionID_t& ref_ricActionID() {return ricActionID;} + ricActionID_t const& ref_ricActionID() const {return ricActionID;} + template void decode(V& v) + { + v(ricActionID); + + }; + template void encode(V& v) const + { + v(ricActionID); + + }; + void clear() + { + ricActionID.clear(); + + }; + private: + ricActionID_t ricActionID; + +}; +/* +RICaction-Admitted-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RICaction-Admitted-Item CRITICALITY ignore TYPE RICaction-Admitted-Item PRESENCE mandatory }, + ... +} +*/ + +struct RICaction_Admitted_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_Admitted_Item() { set(id_RICaction_Admitted_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICaction_Admitted_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICaction_Admitted_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_Admitted_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICaction_Admitted_Item& select_id_RICaction_Admitted_Item() { return set(1); } + RICaction_Admitted_Item const* get_id_RICaction_Admitted_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICaction_Admitted_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RICaction_Admitted_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_Admitted_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICaction-Admitted-List ::= SEQUENCE (SIZE(1..maxofRICactionID)) OF ProtocolIE-Single-Container{{RICaction-Admitted-ItemIEs}} +*/ + +struct RICaction_Admitted_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RICaction_Admitted_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RICaction_Admitted_List : asn::sequenceof +{ + static constexpr const char* name() {return "RICaction-Admitted-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RICaction-NotAdmitted-Item ::= SEQUENCE { + ricActionID RICactionID, + ricCause RICcause, + ... +} +*/ + +struct RICaction_NotAdmitted_Item : asn::sequence<2, 0, true, 0> +{ + static constexpr const char* name() {return "RICaction-NotAdmitted-Item";} + using parent_t = asn::sequence<2, 0, true, 0>; + struct ricActionID_t : RICactionID + { + static constexpr const char* name() {return "ricActionID_t";} + using parent_t = RICactionID; + + }; + ricActionID_t& ref_ricActionID() {return ricActionID;} + ricActionID_t const& ref_ricActionID() const {return ricActionID;} + struct ricCause_t : RICcause + { + static constexpr const char* name() {return "ricCause_t";} + using parent_t = RICcause; + + }; + ricCause_t& ref_ricCause() {return ricCause;} + ricCause_t const& ref_ricCause() const {return ricCause;} + template void decode(V& v) + { + v(ricActionID); + v(ricCause); + + }; + template void encode(V& v) const + { + v(ricActionID); + v(ricCause); + + }; + void clear() + { + ricActionID.clear(); + ricCause.clear(); + + }; + private: + ricActionID_t ricActionID; + ricCause_t ricCause; + +}; +/* +RICaction-NotAdmitted-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RICaction-NotAdmitted-Item CRITICALITY ignore TYPE RICaction-NotAdmitted-Item PRESENCE mandatory }, + ... +} +*/ + +struct RICaction_NotAdmitted_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_NotAdmitted_Item() { set(id_RICaction_NotAdmitted_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICaction_NotAdmitted_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICaction_NotAdmitted_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_NotAdmitted_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICaction_NotAdmitted_Item& select_id_RICaction_NotAdmitted_Item() { return set(1); } + RICaction_NotAdmitted_Item const* get_id_RICaction_NotAdmitted_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICaction_NotAdmitted_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RICaction_NotAdmitted_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_NotAdmitted_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICaction-NotAdmitted-List ::= SEQUENCE (SIZE(0..maxofRICactionID)) OF ProtocolIE-Single-Container { {RICaction-NotAdmitted-ItemIEs} } +*/ + +struct RICaction_NotAdmitted_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RICaction_NotAdmitted_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RICaction_NotAdmitted_List : asn::sequenceof +{ + static constexpr const char* name() {return "RICaction-NotAdmitted-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RICaction-ToBeSetup-Item ::= SEQUENCE { + ricActionID RICactionID, + ricActionType RICactionType, + ricActionDefinition RICactionDefinition OPTIONAL, + ricSubsequentAction RICsubsequentAction OPTIONAL, + ... +} +*/ + +struct RICaction_ToBeSetup_Item : asn::sequence<4, 0, true, 2> +{ + static constexpr const char* name() {return "RICaction-ToBeSetup-Item";} + using parent_t = asn::sequence<4, 0, true, 2>; + struct ricActionID_t : RICactionID + { + static constexpr const char* name() {return "ricActionID_t";} + using parent_t = RICactionID; + + }; + ricActionID_t& ref_ricActionID() {return ricActionID;} + ricActionID_t const& ref_ricActionID() const {return ricActionID;} + struct ricActionType_t : RICactionType + { + static constexpr const char* name() {return "ricActionType_t";} + using parent_t = RICactionType; + + }; + ricActionType_t& ref_ricActionType() {return ricActionType;} + ricActionType_t const& ref_ricActionType() const {return ricActionType;} + struct ricActionDefinition_t : RICactionDefinition + { + static constexpr const char* name() {return "ricActionDefinition_t";} + using parent_t = RICactionDefinition; + static constexpr bool optional = true; + + }; + ricActionDefinition_t& set_ricActionDefinition() { ricActionDefinition.setpresent(true); return ricActionDefinition;} + ricActionDefinition_t const* get_ricActionDefinition() const {return ricActionDefinition.is_valid() ? &ricActionDefinition : nullptr;} + struct ricSubsequentAction_t : RICsubsequentAction + { + static constexpr const char* name() {return "ricSubsequentAction_t";} + using parent_t = RICsubsequentAction; + static constexpr bool optional = true; + + }; + ricSubsequentAction_t& set_ricSubsequentAction() { ricSubsequentAction.setpresent(true); return ricSubsequentAction;} + ricSubsequentAction_t const* get_ricSubsequentAction() const {return ricSubsequentAction.is_valid() ? &ricSubsequentAction : nullptr;} + template void decode(V& v) + { + v(ricActionID); + v(ricActionType); + v(ricActionDefinition); + v(ricSubsequentAction); + + }; + template void encode(V& v) const + { + v(ricActionID); + v(ricActionType); + v(ricActionDefinition); + v(ricSubsequentAction); + + }; + void clear() + { + ricActionID.clear(); + ricActionType.clear(); + ricActionDefinition.clear(); + ricSubsequentAction.clear(); + + }; + private: + ricActionID_t ricActionID; + ricActionType_t ricActionType; + ricActionDefinition_t ricActionDefinition; + ricSubsequentAction_t ricSubsequentAction; + +}; +/* +RICaction-ToBeSetup-ItemIEs X2AP-PROTOCOL-IES ::= { + { ID id-RICaction-ToBeSetup-Item CRITICALITY ignore TYPE RICaction-ToBeSetup-Item PRESENCE mandatory }, + ... +} +*/ + +struct RICaction_ToBeSetup_ItemIEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_ToBeSetup_Item() { set(id_RICaction_ToBeSetup_Item); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICaction_ToBeSetup_Item)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICaction_ToBeSetup_Item);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_ToBeSetup_Item() { set(ignore); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(ignore)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICaction_ToBeSetup_Item& select_id_RICaction_ToBeSetup_Item() { return set(1); } + RICaction_ToBeSetup_Item const* get_id_RICaction_ToBeSetup_Item() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICaction_ToBeSetup_Item()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RICaction_ToBeSetup_Item)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RICaction_ToBeSetup_Item() { set(mandatory); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICactions-ToBeSetup-List ::= SEQUENCE (SIZE(1..maxofRICactionID)) OF ProtocolIE-Single-Container { {RICaction-ToBeSetup-ItemIEs} } +*/ + +struct RICactions_ToBeSetup_List_elm : ProtocolIE_Single_Container +{ + static constexpr const char* name() {return "RICactions_ToBeSetup_List_elm";} + using parent_t = ProtocolIE_Single_Container; + +}; +struct RICactions_ToBeSetup_List : asn::sequenceof +{ + static constexpr const char* name() {return "RICactions-ToBeSetup-List";} + using parent_t = asn::sequenceof; + using constraint_t = asn::constraints>; + +}; +/* +RICcontrolAcknowledge-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional}| + { ID id-RICcontrolStatus CRITICALITY reject TYPE RICcontrolStatus PRESENCE mandatory}, + ... +} +*/ + +struct RICcontrolAcknowledge_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICcallProcessID() { set(id_RICcallProcessID); type=3;} + void select_id_RICcontrolStatus() { set(id_RICcontrolStatus); type=4;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICcallProcessID)) { type = 3; return true; } + else if(equal(id_RICcontrolStatus)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICcallProcessID);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_RICcontrolStatus);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICcallProcessID() { set(reject); type=3;} + void select_id_RICcontrolStatus() { set(reject); type=4;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(reject)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICcallProcessID& select_id_RICcallProcessID() { return set(3); } + RICcallProcessID const* get_id_RICcallProcessID() const { return get(3); } + RICcontrolStatus& select_id_RICcontrolStatus() { return set(4); } + RICcontrolStatus const* get_id_RICcontrolStatus() const { return get(4); } + bool is_unknown() const { return type == 5; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICcallProcessID()); return true; + case 4: v(select_id_RICcontrolStatus()); return true; + case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICcallProcessID)]; + char dummy3[sizeof(RICcontrolStatus)]; + char dummy4[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICcallProcessID() { set(optional); type=3;} + void select_id_RICcontrolStatus() { set(mandatory); type=4;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(optional)) { type = 3; return true; } + else if(equal(mandatory)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICcontrolAcknowledge ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICcontrolAcknowledge-IEs}}, + ... +} +*/ + +struct RICcontrolAcknowledge : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICcontrolAcknowledge";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICcontrolFailure-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional}| + { ID id-RICcause CRITICALITY reject TYPE RICcause PRESENCE mandatory}, + ... +} +*/ + +struct RICcontrolFailure_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICcallProcessID() { set(id_RICcallProcessID); type=3;} + void select_id_RICcause() { set(id_RICcause); type=4;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICcallProcessID)) { type = 3; return true; } + else if(equal(id_RICcause)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICcallProcessID);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_RICcause);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICcallProcessID() { set(reject); type=3;} + void select_id_RICcause() { set(reject); type=4;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(reject)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICcallProcessID& select_id_RICcallProcessID() { return set(3); } + RICcallProcessID const* get_id_RICcallProcessID() const { return get(3); } + RICcause& select_id_RICcause() { return set(4); } + RICcause const* get_id_RICcause() const { return get(4); } + bool is_unknown() const { return type == 5; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICcallProcessID()); return true; + case 4: v(select_id_RICcause()); return true; + case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICcallProcessID)]; + char dummy3[sizeof(RICcause)]; + char dummy4[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICcallProcessID() { set(optional); type=3;} + void select_id_RICcause() { set(mandatory); type=4;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(optional)) { type = 3; return true; } + else if(equal(mandatory)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICcontrolFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICcontrolFailure-IEs}}, + ... +} +*/ + +struct RICcontrolFailure : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICcontrolFailure";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICcontrolRequest-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional}| + { ID id-RICcontrolHeader CRITICALITY reject TYPE RICcontrolHeader PRESENCE mandatory}| + { ID id-RICcontrolMessage CRITICALITY reject TYPE RICcontrolMessage PRESENCE mandatory}| + { ID id-RICcontrolAckRequest CRITICALITY reject TYPE RICcontrolAckRequest PRESENCE optional}, + ... +} +*/ + +struct RICcontrolRequest_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 7; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICcallProcessID() { set(id_RICcallProcessID); type=3;} + void select_id_RICcontrolHeader() { set(id_RICcontrolHeader); type=4;} + void select_id_RICcontrolMessage() { set(id_RICcontrolMessage); type=5;} + void select_id_RICcontrolAckRequest() { set(id_RICcontrolAckRequest); type=6;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICcallProcessID)) { type = 3; return true; } + else if(equal(id_RICcontrolHeader)) { type = 4; return true; } + else if(equal(id_RICcontrolMessage)) { type = 5; return true; } + else if(equal(id_RICcontrolAckRequest)) { type = 6; return true; } + else { type = 7; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICcallProcessID);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_RICcontrolHeader);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(id_RICcontrolMessage);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(id_RICcontrolAckRequest);} return false; + case 7: type = 7; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 7; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICcallProcessID() { set(reject); type=3;} + void select_id_RICcontrolHeader() { set(reject); type=4;} + void select_id_RICcontrolMessage() { set(reject); type=5;} + void select_id_RICcontrolAckRequest() { set(reject); type=6;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(reject)) { type = 4; return true; } + else if(equal(reject)) { type = 5; return true; } + else if(equal(reject)) { type = 6; return true; } + else { type = 7; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false; + case 7: type = 7; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICcallProcessID& select_id_RICcallProcessID() { return set(3); } + RICcallProcessID const* get_id_RICcallProcessID() const { return get(3); } + RICcontrolHeader& select_id_RICcontrolHeader() { return set(4); } + RICcontrolHeader const* get_id_RICcontrolHeader() const { return get(4); } + RICcontrolMessage& select_id_RICcontrolMessage() { return set(5); } + RICcontrolMessage const* get_id_RICcontrolMessage() const { return get(5); } + RICcontrolAckRequest& select_id_RICcontrolAckRequest() { return set(6); } + RICcontrolAckRequest const* get_id_RICcontrolAckRequest() const { return get(6); } + bool is_unknown() const { return type == 7; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + case 5: var.destroy(); break; + case 6: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + v.template operator()(5); + v.template operator()(6); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICcallProcessID()); return true; + case 4: v(select_id_RICcontrolHeader()); return true; + case 5: v(select_id_RICcontrolMessage()); return true; + case 6: v(select_id_RICcontrolAckRequest()); return true; + case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + case 5: v(var.as()); return true; + case 6: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICcallProcessID)]; + char dummy3[sizeof(RICcontrolAckRequest)]; + char dummy4[sizeof(RICcontrolHeader)]; + char dummy5[sizeof(RICcontrolMessage)]; + char dummy6[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 7; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICcallProcessID() { set(optional); type=3;} + void select_id_RICcontrolHeader() { set(mandatory); type=4;} + void select_id_RICcontrolMessage() { set(mandatory); type=5;} + void select_id_RICcontrolAckRequest() { set(optional); type=6;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(optional)) { type = 3; return true; } + else if(equal(mandatory)) { type = 4; return true; } + else if(equal(mandatory)) { type = 5; return true; } + else if(equal(optional)) { type = 6; return true; } + else { type = 7; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false; + case 7: type = 7; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICcontrolRequest ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICcontrolRequest-IEs}}, + ... +} +*/ + +struct RICcontrolRequest : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICcontrolRequest";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICindication-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICactionID CRITICALITY reject TYPE RICactionID PRESENCE mandatory}| + { ID id-RICindicationSN CRITICALITY reject TYPE RICindicationSN PRESENCE mandatory}| + { ID id-RICindicationType CRITICALITY reject TYPE RICindicationType PRESENCE mandatory}| + { ID id-RICindicationHeader CRITICALITY reject TYPE RICindicationHeader PRESENCE mandatory}| + { ID id-RICindicationMessage CRITICALITY reject TYPE RICindicationMessage PRESENCE mandatory} | + { ID id-RICcallProcessID CRITICALITY reject TYPE RICcallProcessID PRESENCE optional}, + ... +} +*/ + +struct RICindication_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 9; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICactionID() { set(id_RICactionID); type=3;} + void select_id_RICindicationSN() { set(id_RICindicationSN); type=4;} + void select_id_RICindicationType() { set(id_RICindicationType); type=5;} + void select_id_RICindicationHeader() { set(id_RICindicationHeader); type=6;} + void select_id_RICindicationMessage() { set(id_RICindicationMessage); type=7;} + void select_id_RICcallProcessID() { set(id_RICcallProcessID); type=8;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICactionID)) { type = 3; return true; } + else if(equal(id_RICindicationSN)) { type = 4; return true; } + else if(equal(id_RICindicationType)) { type = 5; return true; } + else if(equal(id_RICindicationHeader)) { type = 6; return true; } + else if(equal(id_RICindicationMessage)) { type = 7; return true; } + else if(equal(id_RICcallProcessID)) { type = 8; return true; } + else { type = 9; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICactionID);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_RICindicationSN);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(id_RICindicationType);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(id_RICindicationHeader);} return false; + case 7: type = 7; if(v(ref_nested())) { return equal(id_RICindicationMessage);} return false; + case 8: type = 8; if(v(ref_nested())) { return equal(id_RICcallProcessID);} return false; + case 9: type = 9; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 9; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICactionID() { set(reject); type=3;} + void select_id_RICindicationSN() { set(reject); type=4;} + void select_id_RICindicationType() { set(reject); type=5;} + void select_id_RICindicationHeader() { set(reject); type=6;} + void select_id_RICindicationMessage() { set(reject); type=7;} + void select_id_RICcallProcessID() { set(reject); type=8;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(reject)) { type = 4; return true; } + else if(equal(reject)) { type = 5; return true; } + else if(equal(reject)) { type = 6; return true; } + else if(equal(reject)) { type = 7; return true; } + else if(equal(reject)) { type = 8; return true; } + else { type = 9; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false; + case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false; + case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false; + case 9: type = 9; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICactionID& select_id_RICactionID() { return set(3); } + RICactionID const* get_id_RICactionID() const { return get(3); } + RICindicationSN& select_id_RICindicationSN() { return set(4); } + RICindicationSN const* get_id_RICindicationSN() const { return get(4); } + RICindicationType& select_id_RICindicationType() { return set(5); } + RICindicationType const* get_id_RICindicationType() const { return get(5); } + RICindicationHeader& select_id_RICindicationHeader() { return set(6); } + RICindicationHeader const* get_id_RICindicationHeader() const { return get(6); } + RICindicationMessage& select_id_RICindicationMessage() { return set(7); } + RICindicationMessage const* get_id_RICindicationMessage() const { return get(7); } + RICcallProcessID& select_id_RICcallProcessID() { return set(8); } + RICcallProcessID const* get_id_RICcallProcessID() const { return get(8); } + bool is_unknown() const { return type == 9; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + case 5: var.destroy(); break; + case 6: var.destroy(); break; + case 7: var.destroy(); break; + case 8: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + v.template operator()(5); + v.template operator()(6); + v.template operator()(7); + v.template operator()(8); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICactionID()); return true; + case 4: v(select_id_RICindicationSN()); return true; + case 5: v(select_id_RICindicationType()); return true; + case 6: v(select_id_RICindicationHeader()); return true; + case 7: v(select_id_RICindicationMessage()); return true; + case 8: v(select_id_RICcallProcessID()); return true; + case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + case 5: v(var.as()); return true; + case 6: v(var.as()); return true; + case 7: v(var.as()); return true; + case 8: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICactionID)]; + char dummy3[sizeof(RICcallProcessID)]; + char dummy4[sizeof(RICindicationHeader)]; + char dummy5[sizeof(RICindicationMessage)]; + char dummy6[sizeof(RICindicationSN)]; + char dummy7[sizeof(RICindicationType)]; + char dummy8[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 9; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICactionID() { set(mandatory); type=3;} + void select_id_RICindicationSN() { set(mandatory); type=4;} + void select_id_RICindicationType() { set(mandatory); type=5;} + void select_id_RICindicationHeader() { set(mandatory); type=6;} + void select_id_RICindicationMessage() { set(mandatory); type=7;} + void select_id_RICcallProcessID() { set(optional); type=8;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(mandatory)) { type = 3; return true; } + else if(equal(mandatory)) { type = 4; return true; } + else if(equal(mandatory)) { type = 5; return true; } + else if(equal(mandatory)) { type = 6; return true; } + else if(equal(mandatory)) { type = 7; return true; } + else if(equal(optional)) { type = 8; return true; } + else { type = 9; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false; + case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false; + case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false; + case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} return false; + case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false; + case 9: type = 9; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICindication ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICindication-IEs}}, + ... +} +*/ + +struct RICindication : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICindication";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICserviceQuery-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionsAccepted CRITICALITY reject TYPE RANfunctionsID-List PRESENCE optional}, + ... +} +*/ + +struct RICserviceQuery_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(id_RANfunctionsAccepted); type=1;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionsAccepted)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionsAccepted);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(reject); type=1;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctionsID_List& select_id_RANfunctionsAccepted() { return set(1); } + RANfunctionsID_List const* get_id_RANfunctionsAccepted() const { return get(1); } + bool is_unknown() const { return type == 2; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionsAccepted()); return true; + case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionsID_List)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 2; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(optional); type=1;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(optional)) { type = 1; return true; } + else { type = 2; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false; + case 2: type = 2; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICserviceQuery ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICserviceQuery-IEs}}, + ... +} +*/ + +struct RICserviceQuery : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICserviceQuery";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICserviceUpdate-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionsAdded CRITICALITY reject TYPE RANfunctions-List PRESENCE optional}| + { ID id-RANfunctionsModified CRITICALITY reject TYPE RANfunctions-List PRESENCE optional}| + { ID id-RANfunctionsDeleted CRITICALITY reject TYPE RANfunctionsID-List PRESENCE optional}, + ... +} +*/ + +struct RICserviceUpdate_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsAdded() { set(id_RANfunctionsAdded); type=1;} + void select_id_RANfunctionsModified() { set(id_RANfunctionsModified); type=2;} + void select_id_RANfunctionsDeleted() { set(id_RANfunctionsDeleted); type=3;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionsAdded)) { type = 1; return true; } + else if(equal(id_RANfunctionsModified)) { type = 2; return true; } + else if(equal(id_RANfunctionsDeleted)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionsAdded);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionsModified);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RANfunctionsDeleted);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsAdded() { set(reject); type=1;} + void select_id_RANfunctionsModified() { set(reject); type=2;} + void select_id_RANfunctionsDeleted() { set(reject); type=3;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctions_List& select_id_RANfunctionsAdded() { return set(1); } + RANfunctions_List const* get_id_RANfunctionsAdded() const { return get(1); } + RANfunctions_List& select_id_RANfunctionsModified() { return set(2); } + RANfunctions_List const* get_id_RANfunctionsModified() const { return get(2); } + RANfunctionsID_List& select_id_RANfunctionsDeleted() { return set(3); } + RANfunctionsID_List const* get_id_RANfunctionsDeleted() const { return get(3); } + bool is_unknown() const { return type == 4; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionsAdded()); return true; + case 2: v(select_id_RANfunctionsModified()); return true; + case 3: v(select_id_RANfunctionsDeleted()); return true; + case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionsID_List)]; + char dummy2[sizeof(RANfunctions_List)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsAdded() { set(optional); type=1;} + void select_id_RANfunctionsModified() { set(optional); type=2;} + void select_id_RANfunctionsDeleted() { set(optional); type=3;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(optional)) { type = 1; return true; } + else if(equal(optional)) { type = 2; return true; } + else if(equal(optional)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICserviceUpdate ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICserviceUpdate-IEs}}, + ... +} +*/ + +struct RICserviceUpdate : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICserviceUpdate";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICserviceUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionsAccepted CRITICALITY reject TYPE RANfunctionsID-List PRESENCE optional}| + { ID id-RANfunctionsRejected CRITICALITY reject TYPE RANfunctionsIDcause-List PRESENCE optional}, + ... +} +*/ + +struct RICserviceUpdateAcknowledge_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(id_RANfunctionsAccepted); type=1;} + void select_id_RANfunctionsRejected() { set(id_RANfunctionsRejected); type=2;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionsAccepted)) { type = 1; return true; } + else if(equal(id_RANfunctionsRejected)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionsAccepted);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionsRejected);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(reject); type=1;} + void select_id_RANfunctionsRejected() { set(reject); type=2;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctionsID_List& select_id_RANfunctionsAccepted() { return set(1); } + RANfunctionsID_List const* get_id_RANfunctionsAccepted() const { return get(1); } + RANfunctionsIDcause_List& select_id_RANfunctionsRejected() { return set(2); } + RANfunctionsIDcause_List const* get_id_RANfunctionsRejected() const { return get(2); } + bool is_unknown() const { return type == 3; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionsAccepted()); return true; + case 2: v(select_id_RANfunctionsRejected()); return true; + case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionsID_List)]; + char dummy2[sizeof(RANfunctionsIDcause_List)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RANfunctionsAccepted() { set(optional); type=1;} + void select_id_RANfunctionsRejected() { set(optional); type=2;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(optional)) { type = 1; return true; } + else if(equal(optional)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICserviceUpdateAcknowledge ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICserviceUpdateAcknowledge-IEs}}, + ... +} +*/ + +struct RICserviceUpdateAcknowledge : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICserviceUpdateAcknowledge";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICserviceUpdateFailure-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RANfunctionsRejected CRITICALITY reject TYPE RANfunctionsIDcause-List PRESENCE optional}| + { ID id-TimeToWait CRITICALITY ignore TYPE TimeToWait PRESENCE optional}| + { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}, + ... +} +*/ + +struct RICserviceUpdateFailure_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsRejected() { set(id_RANfunctionsRejected); type=1;} + void select_id_TimeToWait() { set(id_TimeToWait); type=2;} + void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RANfunctionsRejected)) { type = 1; return true; } + else if(equal(id_TimeToWait)) { type = 2; return true; } + else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RANfunctionsRejected);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsRejected() { set(reject); type=1;} + void select_id_TimeToWait() { set(ignore); type=2;} + void select_id_CriticalityDiagnostics() { set(ignore); type=3;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(ignore)) { type = 2; return true; } + else if(equal(ignore)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RANfunctionsIDcause_List& select_id_RANfunctionsRejected() { return set(1); } + RANfunctionsIDcause_List const* get_id_RANfunctionsRejected() const { return get(1); } + TimeToWait& select_id_TimeToWait() { return set(2); } + TimeToWait const* get_id_TimeToWait() const { return get(2); } + CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set(3); } + CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get(3); } + bool is_unknown() const { return type == 4; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RANfunctionsRejected()); return true; + case 2: v(select_id_TimeToWait()); return true; + case 3: v(select_id_CriticalityDiagnostics()); return true; + case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(CriticalityDiagnostics)]; + char dummy2[sizeof(RANfunctionsIDcause_List)]; + char dummy3[sizeof(TimeToWait)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RANfunctionsRejected() { set(optional); type=1;} + void select_id_TimeToWait() { set(optional); type=2;} + void select_id_CriticalityDiagnostics() { set(optional); type=3;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(optional)) { type = 1; return true; } + else if(equal(optional)) { type = 2; return true; } + else if(equal(optional)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICserviceUpdateFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICserviceUpdateFailure-IEs}}, + ... +} +*/ + +struct RICserviceUpdateFailure : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICserviceUpdateFailure";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscription ::= SEQUENCE { + ricEventTriggerDefinition RICeventTriggerDefinition, + ricAction-ToBeSetup-List RICactions-ToBeSetup-List, + ... +} +*/ + +struct RICsubscription : asn::sequence<2, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscription";} + using parent_t = asn::sequence<2, 0, true, 0>; + struct ricEventTriggerDefinition_t : RICeventTriggerDefinition + { + static constexpr const char* name() {return "ricEventTriggerDefinition_t";} + using parent_t = RICeventTriggerDefinition; + + }; + ricEventTriggerDefinition_t& ref_ricEventTriggerDefinition() {return ricEventTriggerDefinition;} + ricEventTriggerDefinition_t const& ref_ricEventTriggerDefinition() const {return ricEventTriggerDefinition;} + struct ricAction_ToBeSetup_List_t : RICactions_ToBeSetup_List + { + static constexpr const char* name() {return "ricAction_ToBeSetup_List_t";} + using parent_t = RICactions_ToBeSetup_List; + + }; + ricAction_ToBeSetup_List_t& ref_ricAction_ToBeSetup_List() {return ricAction_ToBeSetup_List;} + ricAction_ToBeSetup_List_t const& ref_ricAction_ToBeSetup_List() const {return ricAction_ToBeSetup_List;} + template void decode(V& v) + { + v(ricEventTriggerDefinition); + v(ricAction_ToBeSetup_List); + + }; + template void encode(V& v) const + { + v(ricEventTriggerDefinition); + v(ricAction_ToBeSetup_List); + + }; + void clear() + { + ricEventTriggerDefinition.clear(); + ricAction_ToBeSetup_List.clear(); + + }; + private: + ricEventTriggerDefinition_t ricEventTriggerDefinition; + ricAction_ToBeSetup_List_t ricAction_ToBeSetup_List; + +}; +/* +RICsubscriptionDeleteFailure-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICcause CRITICALITY reject TYPE RICcause PRESENCE mandatory}| + { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}, + ... +} +*/ + +struct RICsubscriptionDeleteFailure_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICcause() { set(id_RICcause); type=3;} + void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICcause)) { type = 3; return true; } + else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICcause);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICcause() { set(reject); type=3;} + void select_id_CriticalityDiagnostics() { set(ignore); type=4;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(ignore)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICcause& select_id_RICcause() { return set(3); } + RICcause const* get_id_RICcause() const { return get(3); } + CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set(4); } + CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get(4); } + bool is_unknown() const { return type == 5; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICcause()); return true; + case 4: v(select_id_CriticalityDiagnostics()); return true; + case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(CriticalityDiagnostics)]; + char dummy2[sizeof(RANfunctionID)]; + char dummy3[sizeof(RICcause)]; + char dummy4[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICcause() { set(mandatory); type=3;} + void select_id_CriticalityDiagnostics() { set(optional); type=4;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(mandatory)) { type = 3; return true; } + else if(equal(optional)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionDeleteFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionDeleteFailure-IEs}}, + ... +} +*/ + +struct RICsubscriptionDeleteFailure : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionDeleteFailure";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscriptionDeleteRequest-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}, + ... +} +*/ + +struct RICsubscriptionDeleteRequest_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + bool is_unknown() const { return type == 3; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionDeleteRequest ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionDeleteRequest-IEs}}, + ... +} +*/ + +struct RICsubscriptionDeleteRequest : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionDeleteRequest";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscriptionDeleteResponse-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}, + ... +} +*/ + +struct RICsubscriptionDeleteResponse_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + bool is_unknown() const { return type == 3; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 3; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else { type = 3; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionDeleteResponse ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionDeleteResponse-IEs}}, + ... +} +*/ + +struct RICsubscriptionDeleteResponse : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionDeleteResponse";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscriptionFailure-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICactions-NotAdmitted CRITICALITY reject TYPE RICaction-NotAdmitted-List PRESENCE mandatory}| + { ID id-CriticalityDiagnostics CRITICALITY ignore TYPE CriticalityDiagnostics PRESENCE optional}, + ... +} +*/ + +struct RICsubscriptionFailure_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICactions_NotAdmitted() { set(id_RICactions_NotAdmitted); type=3;} + void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICactions_NotAdmitted)) { type = 3; return true; } + else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICactions_NotAdmitted);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICactions_NotAdmitted() { set(reject); type=3;} + void select_id_CriticalityDiagnostics() { set(ignore); type=4;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(ignore)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICaction_NotAdmitted_List& select_id_RICactions_NotAdmitted() { return set(3); } + RICaction_NotAdmitted_List const* get_id_RICactions_NotAdmitted() const { return get(3); } + CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set(4); } + CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get(4); } + bool is_unknown() const { return type == 5; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICactions_NotAdmitted()); return true; + case 4: v(select_id_CriticalityDiagnostics()); return true; + case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(CriticalityDiagnostics)]; + char dummy2[sizeof(RANfunctionID)]; + char dummy3[sizeof(RICaction_NotAdmitted_List)]; + char dummy4[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICactions_NotAdmitted() { set(mandatory); type=3;} + void select_id_CriticalityDiagnostics() { set(optional); type=4;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(mandatory)) { type = 3; return true; } + else if(equal(optional)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionFailure ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionFailure-IEs}}, + ... +} +*/ + +struct RICsubscriptionFailure : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionFailure";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscriptionRequest-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory}| + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory}| + { ID id-RICsubscription CRITICALITY reject TYPE RICsubscription PRESENCE mandatory}, + ... +} +*/ + +struct RICsubscriptionRequest_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICsubscription() { set(id_RICsubscription); type=3;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICsubscription)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICsubscription);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICsubscription() { set(reject); type=3;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICsubscription& select_id_RICsubscription() { return set(3); } + RICsubscription const* get_id_RICsubscription() const { return get(3); } + bool is_unknown() const { return type == 4; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICsubscription()); return true; + case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICrequestID)]; + char dummy3[sizeof(RICsubscription)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 4; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICsubscription() { set(mandatory); type=3;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(mandatory)) { type = 3; return true; } + else { type = 4; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false; + case 4: type = 4; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionRequest ::= SEQUENCE { + protocolIEs ProtocolIE-Container {{RICsubscriptionRequest-IEs}}, + ... +} +*/ + +struct RICsubscriptionRequest : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionRequest";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +}; +/* +RICsubscriptionResponse-IEs X2AP-PROTOCOL-IES ::= { + { ID id-RICrequestID CRITICALITY reject TYPE RICrequestID PRESENCE mandatory } | + { ID id-RANfunctionID CRITICALITY reject TYPE RANfunctionID PRESENCE mandatory } | + { ID id-RICactions-Admitted CRITICALITY reject TYPE RICaction-Admitted-List PRESENCE mandatory } | + { ID id-RICactions-NotAdmitted CRITICALITY reject TYPE RICaction-NotAdmitted-List PRESENCE optional }, + ... +} +*/ + +struct RICsubscriptionResponse_IEs +{ + struct id_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(id_RICrequestID); type=1;} + void select_id_RANfunctionID() { set(id_RANfunctionID); type=2;} + void select_id_RICactions_Admitted() { set(id_RICactions_Admitted); type=3;} + void select_id_RICactions_NotAdmitted() { set(id_RICactions_NotAdmitted); type=4;} + X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(id_RICrequestID)) { type = 1; return true; } + else if(equal(id_RANfunctionID)) { type = 2; return true; } + else if(equal(id_RICactions_Admitted)) { type = 3; return true; } + else if(equal(id_RICactions_NotAdmitted)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(id_RICrequestID);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(id_RANfunctionID);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(id_RICactions_Admitted);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(id_RICactions_NotAdmitted);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct criticality_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(reject); type=1;} + void select_id_RANfunctionID() { set(reject); type=2;} + void select_id_RICactions_Admitted() { set(reject); type=3;} + void select_id_RICactions_NotAdmitted() { set(reject); type=4;} + X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(reject)) { type = 1; return true; } + else if(equal(reject)) { type = 2; return true; } + else if(equal(reject)) { type = 3; return true; } + else if(equal(reject)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + struct Value_t : asn::typefield + { + ~Value_t() {clear();} + size_t get_index() const {return type;} + RICrequestID& select_id_RICrequestID() { return set(1); } + RICrequestID const* get_id_RICrequestID() const { return get(1); } + RANfunctionID& select_id_RANfunctionID() { return set(2); } + RANfunctionID const* get_id_RANfunctionID() const { return get(2); } + RICaction_Admitted_List& select_id_RICactions_Admitted() { return set(3); } + RICaction_Admitted_List const* get_id_RICactions_Admitted() const { return get(3); } + RICaction_NotAdmitted_List& select_id_RICactions_NotAdmitted() { return set(4); } + RICaction_NotAdmitted_List const* get_id_RICactions_NotAdmitted() const { return get(4); } + bool is_unknown() const { return type == 5; } + void clear() + { + switch(type) + { + case 1: var.destroy(); break; + case 2: var.destroy(); break; + case 3: var.destroy(); break; + case 4: var.destroy(); break; + } + type = 0; ref_nested().clear(); + } + template static inline void enumerate(V& v) + { + v.template operator()(1); + v.template operator()(2); + v.template operator()(3); + v.template operator()(4); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: v(select_id_RICrequestID()); return true; + case 2: v(select_id_RANfunctionID()); return true; + case 3: v(select_id_RICactions_Admitted()); return true; + case 4: v(select_id_RICactions_NotAdmitted()); return true; + case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true; + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) return false; + switch(type) + { + case 1: v(var.as()); return true; + case 2: v(var.as()); return true; + case 3: v(var.as()); return true; + case 4: v(var.as()); return true; + } + return false; + + } + private: + template T& set(size_t index) {if(type != index) {clear(); type = index; return var.build();} return var.as();} + template T const* get(size_t index) const {if(type == index) {return &var.as();} return nullptr;} + union union_type + { + char dummy1[sizeof(RANfunctionID)]; + char dummy2[sizeof(RICaction_Admitted_List)]; + char dummy3[sizeof(RICaction_NotAdmitted_List)]; + char dummy4[sizeof(RICrequestID)]; + + }; + asn::variant var; + size_t type {0}; + + }; + struct presence_t : asn::fixedtypefield + { + size_t get_index() const {return type;} + bool is_unknown() const { return type == 5; } + void clear() {type = 0;} + void select_id_RICrequestID() { set(mandatory); type=1;} + void select_id_RANfunctionID() { set(mandatory); type=2;} + void select_id_RICactions_Admitted() { set(mandatory); type=3;} + void select_id_RICactions_NotAdmitted() { set(optional); type=4;} + X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();} + template bool decode(V& v) + { + clear(); + if(!v(ref_nested())) return false; + if(equal(mandatory)) { type = 1; return true; } + else if(equal(mandatory)) { type = 2; return true; } + else if(equal(mandatory)) { type = 3; return true; } + else if(equal(optional)) { type = 4; return true; } + else { type = 5; return true;} + return false; + + } + template bool encode(V& v) const + { + return v(ref_nested()); + + } + protected: + template bool decode(size_t index, V& v) + { + clear(); + switch(index) + { + case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false; + case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false; + case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false; + case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false; + case 5: type = 5; return v(ref_nested()); + ref_nested().clear(); + } + return false; + + } + template bool encode(size_t index, V& v) const + { + if(index != type) {return false;} return v(ref_nested()); + + } + private: + size_t type {0}; + + }; + +}; +/* +RICsubscriptionResponse ::= SEQUENCE { + protocolIEs ProtocolIE-Container{{RICsubscriptionResponse-IEs}}, + ... +} +*/ + +struct RICsubscriptionResponse : asn::sequence<1, 0, true, 0> +{ + static constexpr const char* name() {return "RICsubscriptionResponse";} + using parent_t = asn::sequence<1, 0, true, 0>; + struct protocolIEs_t : ProtocolIE_Container + { + static constexpr const char* name() {return "protocolIEs_t";} + using parent_t = ProtocolIE_Container; + + }; + protocolIEs_t& ref_protocolIEs() {return protocolIEs;} + protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;} + template void decode(V& v) + { + v(protocolIEs); + + }; + template void encode(V& v) const + { + v(protocolIEs); + + }; + void clear() + { + protocolIEs.clear(); + + }; + private: + protocolIEs_t protocolIEs; + +};