+++ /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