--- /dev/null
+/*****************************************************************************
+# 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<typename V> void decode(V& v)
+ {
+ v(ranFunctionID);
+ v(ranFunctionDefinition);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunction_Item& select_id_RANfunction_Item() { return set<RANfunction_Item>(1); }
+ RANfunction_Item const* get_id_RANfunction_Item() const { return get<RANfunction_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunction_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunction_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunction_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunction_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<typename V> void decode(V& v)
+ {
+ v(ranFunctionID);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctionID_Item& select_id_RANfunctionID_Item() { return set<RANfunctionID_Item>(1); }
+ RANfunctionID_Item const* get_id_RANfunctionID_Item() const { return get<RANfunctionID_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctionID_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctionID_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctionID_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<typename V> void decode(V& v)
+ {
+ v(ranFunctionID);
+ v(ricCause);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctionIDcause_Item& select_id_RANfunctionIEcause_Item() { return set<RANfunctionIDcause_Item>(1); }
+ RANfunctionIDcause_Item const* get_id_RANfunctionIEcause_Item() const { return get<RANfunctionIDcause_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctionIDcause_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctionIDcause_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctionIDcause_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionIDcause_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RANfunction_ItemIEs>
+{
+ static constexpr const char* name() {return "RANfunctions_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RANfunction_ItemIEs>;
+
+};
+struct RANfunctions_List : asn::sequenceof<RANfunctions_List_elm>
+{
+ static constexpr const char* name() {return "RANfunctions-List";}
+ using parent_t = asn::sequenceof<RANfunctions_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxofRANfunctionID >>;
+
+};
+/*
+RANfunctionsID-List ::= SEQUENCE (SIZE(0..maxofRANfunctionID)) OF ProtocolIE-Single-Container{{RANfunctionID-ItemIEs}}
+*/
+
+struct RANfunctionsID_List_elm : ProtocolIE_Single_Container<RANfunctionID_ItemIEs>
+{
+ static constexpr const char* name() {return "RANfunctionsID_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RANfunctionID_ItemIEs>;
+
+};
+struct RANfunctionsID_List : asn::sequenceof<RANfunctionsID_List_elm>
+{
+ static constexpr const char* name() {return "RANfunctionsID-List";}
+ using parent_t = asn::sequenceof<RANfunctionsID_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxofRANfunctionID >>;
+
+};
+/*
+RANfunctionsIDcause-List ::= SEQUENCE (SIZE(0..maxofRANfunctionID)) OF ProtocolIE-Single-Container { {RANfunctionIDcause-ItemIEs} }
+*/
+
+struct RANfunctionsIDcause_List_elm : ProtocolIE_Single_Container<RANfunctionIDcause_ItemIEs>
+{
+ static constexpr const char* name() {return "RANfunctionsIDcause_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RANfunctionIDcause_ItemIEs>;
+
+};
+struct RANfunctionsIDcause_List : asn::sequenceof<RANfunctionsIDcause_List_elm>
+{
+ static constexpr const char* name() {return "RANfunctionsIDcause-List";}
+ using parent_t = asn::sequenceof<RANfunctionsIDcause_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxofRANfunctionID >>;
+
+};
+/*
+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<typename V> void decode(V& v)
+ {
+ v(ricActionID);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICaction_Admitted_Item& select_id_RICaction_Admitted_Item() { return set<RICaction_Admitted_Item>(1); }
+ RICaction_Admitted_Item const* get_id_RICaction_Admitted_Item() const { return get<RICaction_Admitted_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICaction_Admitted_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICaction_Admitted_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICaction_Admitted_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RICaction_Admitted_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICaction_Admitted_ItemIEs>
+{
+ static constexpr const char* name() {return "RICaction_Admitted_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RICaction_Admitted_ItemIEs>;
+
+};
+struct RICaction_Admitted_List : asn::sequenceof<RICaction_Admitted_List_elm>
+{
+ static constexpr const char* name() {return "RICaction-Admitted-List";}
+ using parent_t = asn::sequenceof<RICaction_Admitted_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxofRICactionID >>;
+
+};
+/*
+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<typename V> void decode(V& v)
+ {
+ v(ricActionID);
+ v(ricCause);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICaction_NotAdmitted_Item& select_id_RICaction_NotAdmitted_Item() { return set<RICaction_NotAdmitted_Item>(1); }
+ RICaction_NotAdmitted_Item const* get_id_RICaction_NotAdmitted_Item() const { return get<RICaction_NotAdmitted_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICaction_NotAdmitted_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICaction_NotAdmitted_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICaction_NotAdmitted_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RICaction_NotAdmitted_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICaction_NotAdmitted_ItemIEs>
+{
+ static constexpr const char* name() {return "RICaction_NotAdmitted_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RICaction_NotAdmitted_ItemIEs>;
+
+};
+struct RICaction_NotAdmitted_List : asn::sequenceof<RICaction_NotAdmitted_List_elm>
+{
+ static constexpr const char* name() {return "RICaction-NotAdmitted-List";}
+ using parent_t = asn::sequenceof<RICaction_NotAdmitted_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxofRICactionID >>;
+
+};
+/*
+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<typename V> void decode(V& v)
+ {
+ v(ricActionID);
+ v(ricActionType);
+ v(ricActionDefinition);
+ v(ricSubsequentAction);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICaction_ToBeSetup_Item& select_id_RICaction_ToBeSetup_Item() { return set<RICaction_ToBeSetup_Item>(1); }
+ RICaction_ToBeSetup_Item const* get_id_RICaction_ToBeSetup_Item() const { return get<RICaction_ToBeSetup_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICaction_ToBeSetup_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICaction_ToBeSetup_Item>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICaction_ToBeSetup_Item>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RICaction_ToBeSetup_Item)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICaction_ToBeSetup_ItemIEs>
+{
+ static constexpr const char* name() {return "RICactions_ToBeSetup_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<RICaction_ToBeSetup_ItemIEs>;
+
+};
+struct RICactions_ToBeSetup_List : asn::sequenceof<RICactions_ToBeSetup_List_elm>
+{
+ static constexpr const char* name() {return "RICactions-ToBeSetup-List";}
+ using parent_t = asn::sequenceof<RICactions_ToBeSetup_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxofRICactionID >>;
+
+};
+/*
+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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICcallProcessID& select_id_RICcallProcessID() { return set<RICcallProcessID>(3); }
+ RICcallProcessID const* get_id_RICcallProcessID() const { return get<RICcallProcessID>(3); }
+ RICcontrolStatus& select_id_RICcontrolStatus() { return set<RICcontrolStatus>(4); }
+ RICcontrolStatus const* get_id_RICcontrolStatus() const { return get<RICcontrolStatus>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICcallProcessID>(); break;
+ case 4: var.destroy<RICcontrolStatus>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICcallProcessID>(3);
+ v.template operator()<RICcontrolStatus>(4);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICcallProcessID>()); return true;
+ case 4: v(var.as<RICcontrolStatus>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID)];
+ char dummy2[sizeof(RICcallProcessID)];
+ char dummy3[sizeof(RICcontrolStatus)];
+ char dummy4[sizeof(RICrequestID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICcontrolAcknowledge_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICcontrolAcknowledge_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICcallProcessID& select_id_RICcallProcessID() { return set<RICcallProcessID>(3); }
+ RICcallProcessID const* get_id_RICcallProcessID() const { return get<RICcallProcessID>(3); }
+ RICcause& select_id_RICcause() { return set<RICcause>(4); }
+ RICcause const* get_id_RICcause() const { return get<RICcause>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICcallProcessID>(); break;
+ case 4: var.destroy<RICcause>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICcallProcessID>(3);
+ v.template operator()<RICcause>(4);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICcallProcessID>()); return true;
+ case 4: v(var.as<RICcause>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID)];
+ char dummy2[sizeof(RICcallProcessID)];
+ char dummy3[sizeof(RICcause)];
+ char dummy4[sizeof(RICrequestID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICcontrolFailure_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICcontrolFailure_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICcallProcessID& select_id_RICcallProcessID() { return set<RICcallProcessID>(3); }
+ RICcallProcessID const* get_id_RICcallProcessID() const { return get<RICcallProcessID>(3); }
+ RICcontrolHeader& select_id_RICcontrolHeader() { return set<RICcontrolHeader>(4); }
+ RICcontrolHeader const* get_id_RICcontrolHeader() const { return get<RICcontrolHeader>(4); }
+ RICcontrolMessage& select_id_RICcontrolMessage() { return set<RICcontrolMessage>(5); }
+ RICcontrolMessage const* get_id_RICcontrolMessage() const { return get<RICcontrolMessage>(5); }
+ RICcontrolAckRequest& select_id_RICcontrolAckRequest() { return set<RICcontrolAckRequest>(6); }
+ RICcontrolAckRequest const* get_id_RICcontrolAckRequest() const { return get<RICcontrolAckRequest>(6); }
+ bool is_unknown() const { return type == 7; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICcallProcessID>(); break;
+ case 4: var.destroy<RICcontrolHeader>(); break;
+ case 5: var.destroy<RICcontrolMessage>(); break;
+ case 6: var.destroy<RICcontrolAckRequest>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICcallProcessID>(3);
+ v.template operator()<RICcontrolHeader>(4);
+ v.template operator()<RICcontrolMessage>(5);
+ v.template operator()<RICcontrolAckRequest>(6);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICcallProcessID>()); return true;
+ case 4: v(var.as<RICcontrolHeader>()); return true;
+ case 5: v(var.as<RICcontrolMessage>()); return true;
+ case 6: v(var.as<RICcontrolAckRequest>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} 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<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICcontrolRequest_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICcontrolRequest_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICactionID& select_id_RICactionID() { return set<RICactionID>(3); }
+ RICactionID const* get_id_RICactionID() const { return get<RICactionID>(3); }
+ RICindicationSN& select_id_RICindicationSN() { return set<RICindicationSN>(4); }
+ RICindicationSN const* get_id_RICindicationSN() const { return get<RICindicationSN>(4); }
+ RICindicationType& select_id_RICindicationType() { return set<RICindicationType>(5); }
+ RICindicationType const* get_id_RICindicationType() const { return get<RICindicationType>(5); }
+ RICindicationHeader& select_id_RICindicationHeader() { return set<RICindicationHeader>(6); }
+ RICindicationHeader const* get_id_RICindicationHeader() const { return get<RICindicationHeader>(6); }
+ RICindicationMessage& select_id_RICindicationMessage() { return set<RICindicationMessage>(7); }
+ RICindicationMessage const* get_id_RICindicationMessage() const { return get<RICindicationMessage>(7); }
+ RICcallProcessID& select_id_RICcallProcessID() { return set<RICcallProcessID>(8); }
+ RICcallProcessID const* get_id_RICcallProcessID() const { return get<RICcallProcessID>(8); }
+ bool is_unknown() const { return type == 9; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICactionID>(); break;
+ case 4: var.destroy<RICindicationSN>(); break;
+ case 5: var.destroy<RICindicationType>(); break;
+ case 6: var.destroy<RICindicationHeader>(); break;
+ case 7: var.destroy<RICindicationMessage>(); break;
+ case 8: var.destroy<RICcallProcessID>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICactionID>(3);
+ v.template operator()<RICindicationSN>(4);
+ v.template operator()<RICindicationType>(5);
+ v.template operator()<RICindicationHeader>(6);
+ v.template operator()<RICindicationMessage>(7);
+ v.template operator()<RICcallProcessID>(8);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICactionID>()); return true;
+ case 4: v(var.as<RICindicationSN>()); return true;
+ case 5: v(var.as<RICindicationType>()); return true;
+ case 6: v(var.as<RICindicationHeader>()); return true;
+ case 7: v(var.as<RICindicationMessage>()); return true;
+ case 8: v(var.as<RICcallProcessID>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} 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<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICindication_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICindication_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctionsID_List& select_id_RANfunctionsAccepted() { return set<RANfunctionsID_List>(1); }
+ RANfunctionsID_List const* get_id_RANfunctionsAccepted() const { return get<RANfunctionsID_List>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctionsID_List>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctionsID_List>(1);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctionsID_List>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionsID_List)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICserviceQuery_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICserviceQuery_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctions_List& select_id_RANfunctionsAdded() { return set<RANfunctions_List>(1); }
+ RANfunctions_List const* get_id_RANfunctionsAdded() const { return get<RANfunctions_List>(1); }
+ RANfunctions_List& select_id_RANfunctionsModified() { return set<RANfunctions_List>(2); }
+ RANfunctions_List const* get_id_RANfunctionsModified() const { return get<RANfunctions_List>(2); }
+ RANfunctionsID_List& select_id_RANfunctionsDeleted() { return set<RANfunctionsID_List>(3); }
+ RANfunctionsID_List const* get_id_RANfunctionsDeleted() const { return get<RANfunctionsID_List>(3); }
+ bool is_unknown() const { return type == 4; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctions_List>(); break;
+ case 2: var.destroy<RANfunctions_List>(); break;
+ case 3: var.destroy<RANfunctionsID_List>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctions_List>(1);
+ v.template operator()<RANfunctions_List>(2);
+ v.template operator()<RANfunctionsID_List>(3);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctions_List>()); return true;
+ case 2: v(var.as<RANfunctions_List>()); return true;
+ case 3: v(var.as<RANfunctionsID_List>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionsID_List)];
+ char dummy2[sizeof(RANfunctions_List)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICserviceUpdate_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICserviceUpdate_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctionsID_List& select_id_RANfunctionsAccepted() { return set<RANfunctionsID_List>(1); }
+ RANfunctionsID_List const* get_id_RANfunctionsAccepted() const { return get<RANfunctionsID_List>(1); }
+ RANfunctionsIDcause_List& select_id_RANfunctionsRejected() { return set<RANfunctionsIDcause_List>(2); }
+ RANfunctionsIDcause_List const* get_id_RANfunctionsRejected() const { return get<RANfunctionsIDcause_List>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctionsID_List>(); break;
+ case 2: var.destroy<RANfunctionsIDcause_List>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctionsID_List>(1);
+ v.template operator()<RANfunctionsIDcause_List>(2);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctionsID_List>()); return true;
+ case 2: v(var.as<RANfunctionsIDcause_List>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionsID_List)];
+ char dummy2[sizeof(RANfunctionsIDcause_List)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICserviceUpdateAcknowledge_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICserviceUpdateAcknowledge_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RANfunctionsIDcause_List& select_id_RANfunctionsRejected() { return set<RANfunctionsIDcause_List>(1); }
+ RANfunctionsIDcause_List const* get_id_RANfunctionsRejected() const { return get<RANfunctionsIDcause_List>(1); }
+ TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
+ TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
+ CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
+ CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
+ bool is_unknown() const { return type == 4; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RANfunctionsIDcause_List>(); break;
+ case 2: var.destroy<TimeToWait>(); break;
+ case 3: var.destroy<CriticalityDiagnostics>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RANfunctionsIDcause_List>(1);
+ v.template operator()<TimeToWait>(2);
+ v.template operator()<CriticalityDiagnostics>(3);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RANfunctionsIDcause_List>()); return true;
+ case 2: v(var.as<TimeToWait>()); return true;
+ case 3: v(var.as<CriticalityDiagnostics>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(CriticalityDiagnostics)];
+ char dummy2[sizeof(RANfunctionsIDcause_List)];
+ char dummy3[sizeof(TimeToWait)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICserviceUpdateFailure_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICserviceUpdateFailure_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<typename V> void decode(V& v)
+ {
+ v(ricEventTriggerDefinition);
+ v(ricAction_ToBeSetup_List);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICcause& select_id_RICcause() { return set<RICcause>(3); }
+ RICcause const* get_id_RICcause() const { return get<RICcause>(3); }
+ CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+ CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICcause>(); break;
+ case 4: var.destroy<CriticalityDiagnostics>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICcause>(3);
+ v.template operator()<CriticalityDiagnostics>(4);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICcause>()); return true;
+ case 4: v(var.as<CriticalityDiagnostics>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(CriticalityDiagnostics)];
+ char dummy2[sizeof(RANfunctionID)];
+ char dummy3[sizeof(RICcause)];
+ char dummy4[sizeof(RICrequestID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionDeleteFailure_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionDeleteFailure_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID)];
+ char dummy2[sizeof(RICrequestID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionDeleteRequest_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionDeleteRequest_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID)];
+ char dummy2[sizeof(RICrequestID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionDeleteResponse_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionDeleteResponse_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICaction_NotAdmitted_List& select_id_RICactions_NotAdmitted() { return set<RICaction_NotAdmitted_List>(3); }
+ RICaction_NotAdmitted_List const* get_id_RICactions_NotAdmitted() const { return get<RICaction_NotAdmitted_List>(3); }
+ CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
+ CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICaction_NotAdmitted_List>(); break;
+ case 4: var.destroy<CriticalityDiagnostics>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICaction_NotAdmitted_List>(3);
+ v.template operator()<CriticalityDiagnostics>(4);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICaction_NotAdmitted_List>()); return true;
+ case 4: v(var.as<CriticalityDiagnostics>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} 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<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionFailure_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionFailure_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICsubscription& select_id_RICsubscription() { return set<RICsubscription>(3); }
+ RICsubscription const* get_id_RICsubscription() const { return get<RICsubscription>(3); }
+ bool is_unknown() const { return type == 4; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICsubscription>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICsubscription>(3);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICsubscription>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
+ union union_type
+ {
+ char dummy1[sizeof(RANfunctionID)];
+ char dummy2[sizeof(RICrequestID)];
+ char dummy3[sizeof(RICsubscription)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionRequest_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionRequest_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> 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<X2AP_PROTOCOL_IES::id_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<X2AP_PROTOCOL_IES::criticality_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<true>
+ {
+ ~Value_t() {clear();}
+ size_t get_index() const {return type;}
+ RICrequestID& select_id_RICrequestID() { return set<RICrequestID>(1); }
+ RICrequestID const* get_id_RICrequestID() const { return get<RICrequestID>(1); }
+ RANfunctionID& select_id_RANfunctionID() { return set<RANfunctionID>(2); }
+ RANfunctionID const* get_id_RANfunctionID() const { return get<RANfunctionID>(2); }
+ RICaction_Admitted_List& select_id_RICactions_Admitted() { return set<RICaction_Admitted_List>(3); }
+ RICaction_Admitted_List const* get_id_RICactions_Admitted() const { return get<RICaction_Admitted_List>(3); }
+ RICaction_NotAdmitted_List& select_id_RICactions_NotAdmitted() { return set<RICaction_NotAdmitted_List>(4); }
+ RICaction_NotAdmitted_List const* get_id_RICactions_NotAdmitted() const { return get<RICaction_NotAdmitted_List>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICrequestID>(); break;
+ case 2: var.destroy<RANfunctionID>(); break;
+ case 3: var.destroy<RICaction_Admitted_List>(); break;
+ case 4: var.destroy<RICaction_NotAdmitted_List>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICrequestID>(1);
+ v.template operator()<RANfunctionID>(2);
+ v.template operator()<RICaction_Admitted_List>(3);
+ v.template operator()<RICaction_NotAdmitted_List>(4);
+
+ }
+ protected:
+ template<typename V> 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<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ switch(type)
+ {
+ case 1: v(var.as<RICrequestID>()); return true;
+ case 2: v(var.as<RANfunctionID>()); return true;
+ case 3: v(var.as<RICaction_Admitted_List>()); return true;
+ case 4: v(var.as<RICaction_NotAdmitted_List>()); return true;
+ }
+ return false;
+
+ }
+ private:
+ template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
+ template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} 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<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
+ {
+ 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<typename V> 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<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> 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<typename V> 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<RICsubscriptionResponse_IEs>
+ {
+ static constexpr const char* name() {return "protocolIEs_t";}
+ using parent_t = ProtocolIE_Container<RICsubscriptionResponse_IEs>;
+
+ };
+ protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
+ protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
+ template<typename V> void decode(V& v)
+ {
+ v(protocolIEs);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(protocolIEs);
+
+ };
+ void clear()
+ {
+ protocolIEs.clear();
+
+ };
+ private:
+ protocolIEs_t protocolIEs;
+
+};
Code Review / sim / e2-interface.git / blobdiff