--- /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 "X2AP-Constants.hpp"
+#include "X2AP-CommonDataTypes.hpp"
+#include "X2AP-Containers.hpp"
+
+/*
+DL-ABS-status::= INTEGER (0..100)
+*/
+
+struct DL_ABS_status : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "DL-ABS-status";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UsableABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UsableABSInformationFDD_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UsableABSInformationFDD ::= SEQUENCE {
+ usable-abs-pattern-info BIT STRING (SIZE(40)),
+ iE-Extensions ProtocolExtensionContainer { {UsableABSInformationFDD-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UsableABSInformationFDD : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "UsableABSInformationFDD";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct usable_abs_pattern_info_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<40>>;
+ static constexpr const char* name() {return "usable_abs_pattern_info_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ usable_abs_pattern_info_t& ref_usable_abs_pattern_info() {return usable_abs_pattern_info;}
+ usable_abs_pattern_info_t const& ref_usable_abs_pattern_info() const {return usable_abs_pattern_info;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(usable_abs_pattern_info);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(usable_abs_pattern_info);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ usable_abs_pattern_info.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ usable_abs_pattern_info_t usable_abs_pattern_info;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UsableABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UsableABSInformationTDD_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UsableABSInformationTDD ::= SEQUENCE {
+ usaable-abs-pattern-info BIT STRING (SIZE(1..70, ...)),
+ iE-Extensions ProtocolExtensionContainer { {UsableABSInformationTDD-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UsableABSInformationTDD : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "UsableABSInformationTDD";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct usaable_abs_pattern_info_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+ static constexpr const char* name() {return "usaable_abs_pattern_info_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ usaable_abs_pattern_info_t& ref_usaable_abs_pattern_info() {return usaable_abs_pattern_info;}
+ usaable_abs_pattern_info_t const& ref_usaable_abs_pattern_info() const {return usaable_abs_pattern_info;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(usaable_abs_pattern_info);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(usaable_abs_pattern_info);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ usaable_abs_pattern_info.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ usaable_abs_pattern_info_t usaable_abs_pattern_info;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UsableABSInformation ::= CHOICE {
+ fdd UsableABSInformationFDD,
+ tdd UsableABSInformationTDD,
+ ...
+}
+*/
+
+struct UsableABSInformation : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "UsableABSInformation";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~UsableABSInformation() {clear();}
+ struct fdd_t : UsableABSInformationFDD
+ {
+ static constexpr const char* name() {return "fdd_t";}
+ using parent_t = UsableABSInformationFDD;
+
+ };
+ struct tdd_t : UsableABSInformationTDD
+ {
+ static constexpr const char* name() {return "tdd_t";}
+ using parent_t = UsableABSInformationTDD;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<fdd_t>(); break;
+ case 2: var.destroy<tdd_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<fdd_t>());
+ case 2: set_index(2); return v(var.build<tdd_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<fdd_t>());
+ case 2: return v(var.as<tdd_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<fdd_t>(1);
+ v.template operator()<tdd_t>(2);
+
+ }
+ fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
+ fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
+ tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
+ tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(fdd_t)];
+ char dummy2[sizeof(tdd_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+ABS-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ABS_Status_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ABS-Status ::= SEQUENCE {
+ dL-ABS-status DL-ABS-status,
+ usableABSInformation UsableABSInformation,
+ iE-Extensions ProtocolExtensionContainer { {ABS-Status-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ABS_Status : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ABS-Status";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct dL_ABS_status_t : DL_ABS_status
+ {
+ static constexpr const char* name() {return "dL_ABS_status_t";}
+ using parent_t = DL_ABS_status;
+
+ };
+ dL_ABS_status_t& ref_dL_ABS_status() {return dL_ABS_status;}
+ dL_ABS_status_t const& ref_dL_ABS_status() const {return dL_ABS_status;}
+ struct usableABSInformation_t : UsableABSInformation
+ {
+ static constexpr const char* name() {return "usableABSInformation_t";}
+ using parent_t = UsableABSInformation;
+
+ };
+ usableABSInformation_t& ref_usableABSInformation() {return usableABSInformation;}
+ usableABSInformation_t const& ref_usableABSInformation() const {return usableABSInformation;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ABS_Status_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ABS_Status_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dL_ABS_status);
+ v(usableABSInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dL_ABS_status);
+ v(usableABSInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dL_ABS_status.clear();
+ usableABSInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dL_ABS_status_t dL_ABS_status;
+ usableABSInformation_t usableABSInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ABSInformationFDD_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ABSInformationFDD ::= SEQUENCE {
+ abs-pattern-info BIT STRING (SIZE(40)),
+ numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
+ measurement-subset BIT STRING (SIZE(40)),
+ iE-Extensions ProtocolExtensionContainer { {ABSInformationFDD-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ABSInformationFDD : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "ABSInformationFDD";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct abs_pattern_info_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<40>>;
+ static constexpr const char* name() {return "abs_pattern_info_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
+ abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
+ struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+ {
+ static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ one
+ ,two
+ ,four
+ } index_t;
+
+ };
+
+ numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+ numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+ struct measurement_subset_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<40>>;
+ static constexpr const char* name() {return "measurement_subset_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
+ measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(abs_pattern_info);
+ v(numberOfCellSpecificAntennaPorts);
+ v(measurement_subset);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(abs_pattern_info);
+ v(numberOfCellSpecificAntennaPorts);
+ v(measurement_subset);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ abs_pattern_info.clear();
+ numberOfCellSpecificAntennaPorts.clear();
+ measurement_subset.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ abs_pattern_info_t abs_pattern_info;
+ numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
+ measurement_subset_t measurement_subset;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ABSInformationTDD_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ABSInformationTDD ::= SEQUENCE {
+ abs-pattern-info BIT STRING (SIZE(1..70, ...)),
+ numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
+ measurement-subset BIT STRING (SIZE(1..70, ...)),
+ iE-Extensions ProtocolExtensionContainer { {ABSInformationTDD-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ABSInformationTDD : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "ABSInformationTDD";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct abs_pattern_info_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+ static constexpr const char* name() {return "abs_pattern_info_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
+ abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
+ struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+ {
+ static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ one
+ ,two
+ ,four
+ } index_t;
+
+ };
+
+ numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+ numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+ struct measurement_subset_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 70>>;
+ static constexpr const char* name() {return "measurement_subset_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
+ measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(abs_pattern_info);
+ v(numberOfCellSpecificAntennaPorts);
+ v(measurement_subset);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(abs_pattern_info);
+ v(numberOfCellSpecificAntennaPorts);
+ v(measurement_subset);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ abs_pattern_info.clear();
+ numberOfCellSpecificAntennaPorts.clear();
+ measurement_subset.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ abs_pattern_info_t abs_pattern_info;
+ numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
+ measurement_subset_t measurement_subset;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ABSInformation ::= CHOICE {
+ fdd ABSInformationFDD,
+ tdd ABSInformationTDD,
+ abs-inactive NULL,
+ ...
+}
+*/
+
+struct ABSInformation : asn::choice<3, 0, true>
+{
+ static constexpr const char* name() {return "ABSInformation";}
+ using parent_t = asn::choice<3, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 4;}
+ void set_unknown() { set_index(4); }
+ ~ABSInformation() {clear();}
+ struct fdd_t : ABSInformationFDD
+ {
+ static constexpr const char* name() {return "fdd_t";}
+ using parent_t = ABSInformationFDD;
+
+ };
+ struct tdd_t : ABSInformationTDD
+ {
+ static constexpr const char* name() {return "tdd_t";}
+ using parent_t = ABSInformationTDD;
+
+ };
+ struct abs_inactive_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "abs_inactive_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<fdd_t>(); break;
+ case 2: var.destroy<tdd_t>(); break;
+ case 3: var.destroy<abs_inactive_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<fdd_t>());
+ case 2: set_index(2); return v(var.build<tdd_t>());
+ case 3: set_index(3); return v(var.build<abs_inactive_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<fdd_t>());
+ case 2: return v(var.as<tdd_t>());
+ case 3: return v(var.as<abs_inactive_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<fdd_t>(1);
+ v.template operator()<tdd_t>(2);
+ v.template operator()<abs_inactive_t>(3);
+
+ }
+ fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
+ fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
+ tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
+ tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
+ abs_inactive_t& select_abs_inactive() { if(get_index() != 3) { clear(); set_index(3); return var.build<abs_inactive_t>();} return var.as<abs_inactive_t>();}
+ abs_inactive_t const* get_abs_inactive() const { if(get_index() == 3) { return &var.as<abs_inactive_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(fdd_t)];
+ char dummy2[sizeof(tdd_t)];
+ char dummy3[sizeof(abs_inactive_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+Key-eNodeB-Star ::= BIT STRING (SIZE(256))
+*/
+
+struct Key_eNodeB_Star : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<256>>;
+ static constexpr const char* name() {return "Key-eNodeB-Star";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+NextHopChainingCount ::= INTEGER (0..7)
+*/
+
+struct NextHopChainingCount : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 7>>;
+ static constexpr const char* name() {return "NextHopChainingCount";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+AS-SecurityInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct AS_SecurityInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+AS-SecurityInformation ::= SEQUENCE {
+ key-eNodeB-star Key-eNodeB-Star,
+ nextHopChainingCount NextHopChainingCount,
+ iE-Extensions ProtocolExtensionContainer { {AS-SecurityInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct AS_SecurityInformation : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "AS-SecurityInformation";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct key_eNodeB_star_t : Key_eNodeB_Star
+ {
+ static constexpr const char* name() {return "key_eNodeB_star_t";}
+ using parent_t = Key_eNodeB_Star;
+
+ };
+ key_eNodeB_star_t& ref_key_eNodeB_star() {return key_eNodeB_star;}
+ key_eNodeB_star_t const& ref_key_eNodeB_star() const {return key_eNodeB_star;}
+ struct nextHopChainingCount_t : NextHopChainingCount
+ {
+ static constexpr const char* name() {return "nextHopChainingCount_t";}
+ using parent_t = NextHopChainingCount;
+
+ };
+ nextHopChainingCount_t& ref_nextHopChainingCount() {return nextHopChainingCount;}
+ nextHopChainingCount_t const& ref_nextHopChainingCount() const {return nextHopChainingCount;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(key_eNodeB_star);
+ v(nextHopChainingCount);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(key_eNodeB_star);
+ v(nextHopChainingCount);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ key_eNodeB_star.clear();
+ nextHopChainingCount.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ key_eNodeB_star_t key_eNodeB_star;
+ nextHopChainingCount_t nextHopChainingCount;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ActivationID ::= INTEGER (0..255)
+*/
+
+struct ActivationID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 255>>;
+ static constexpr const char* name() {return "ActivationID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+AdditionalSpecialSubframePatterns ::= ENUMERATED {
+ ssp0,
+ ssp1,
+ ssp2,
+ ssp3,
+ ssp4,
+ ssp5,
+ ssp6,
+ ssp7,
+ ssp8,
+ ssp9,
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframePatterns : asn::enumerated<10, 0, true>
+{
+ static constexpr const char* name() {return "AdditionalSpecialSubframePatterns";}
+ using parent_t = asn::enumerated<10, 0, true>;
+ typedef enum {
+ ssp0
+ ,ssp1
+ ,ssp2
+ ,ssp3
+ ,ssp4
+ ,ssp5
+ ,ssp6
+ ,ssp7
+ ,ssp8
+ ,ssp9
+ } index_t;
+
+};
+
+/*
+CyclicPrefixDL ::= ENUMERATED {
+ normal,
+ extended,
+ ...
+}
+*/
+
+struct CyclicPrefixDL : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "CyclicPrefixDL";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ normal
+ ,extended
+ } index_t;
+
+};
+
+/*
+CyclicPrefixUL ::= ENUMERATED {
+ normal,
+ extended,
+ ...
+}
+*/
+
+struct CyclicPrefixUL : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "CyclicPrefixUL";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ normal
+ ,extended
+ } index_t;
+
+};
+
+/*
+AdditionalSpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframe_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+AdditionalSpecialSubframe-Info ::= SEQUENCE {
+ additionalspecialSubframePatterns AdditionalSpecialSubframePatterns,
+ cyclicPrefixDL CyclicPrefixDL,
+ cyclicPrefixUL CyclicPrefixUL,
+ iE-Extensions ProtocolExtensionContainer { {AdditionalSpecialSubframe-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframe_Info : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "AdditionalSpecialSubframe-Info";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct additionalspecialSubframePatterns_t : AdditionalSpecialSubframePatterns
+ {
+ static constexpr const char* name() {return "additionalspecialSubframePatterns_t";}
+ using parent_t = AdditionalSpecialSubframePatterns;
+
+ };
+ additionalspecialSubframePatterns_t& ref_additionalspecialSubframePatterns() {return additionalspecialSubframePatterns;}
+ additionalspecialSubframePatterns_t const& ref_additionalspecialSubframePatterns() const {return additionalspecialSubframePatterns;}
+ struct cyclicPrefixDL_t : CyclicPrefixDL
+ {
+ static constexpr const char* name() {return "cyclicPrefixDL_t";}
+ using parent_t = CyclicPrefixDL;
+
+ };
+ cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+ cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+ struct cyclicPrefixUL_t : CyclicPrefixUL
+ {
+ static constexpr const char* name() {return "cyclicPrefixUL_t";}
+ using parent_t = CyclicPrefixUL;
+
+ };
+ cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+ cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(additionalspecialSubframePatterns);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(additionalspecialSubframePatterns);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ additionalspecialSubframePatterns.clear();
+ cyclicPrefixDL.clear();
+ cyclicPrefixUL.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ additionalspecialSubframePatterns_t additionalspecialSubframePatterns;
+ cyclicPrefixDL_t cyclicPrefixDL;
+ cyclicPrefixUL_t cyclicPrefixUL;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+AdditionalSpecialSubframePatternsExtension ::= ENUMERATED {
+ ssp10,
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframePatternsExtension : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "AdditionalSpecialSubframePatternsExtension";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ ssp10
+ } index_t;
+
+};
+
+/*
+AdditionalSpecialSubframeExtension-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframeExtension_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+AdditionalSpecialSubframeExtension-Info ::= SEQUENCE {
+ additionalspecialSubframePatternsExtension AdditionalSpecialSubframePatternsExtension,
+ cyclicPrefixDL CyclicPrefixDL,
+ cyclicPrefixUL CyclicPrefixUL,
+ iE-Extensions ProtocolExtensionContainer { {AdditionalSpecialSubframeExtension-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct AdditionalSpecialSubframeExtension_Info : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "AdditionalSpecialSubframeExtension-Info";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct additionalspecialSubframePatternsExtension_t : AdditionalSpecialSubframePatternsExtension
+ {
+ static constexpr const char* name() {return "additionalspecialSubframePatternsExtension_t";}
+ using parent_t = AdditionalSpecialSubframePatternsExtension;
+
+ };
+ additionalspecialSubframePatternsExtension_t& ref_additionalspecialSubframePatternsExtension() {return additionalspecialSubframePatternsExtension;}
+ additionalspecialSubframePatternsExtension_t const& ref_additionalspecialSubframePatternsExtension() const {return additionalspecialSubframePatternsExtension;}
+ struct cyclicPrefixDL_t : CyclicPrefixDL
+ {
+ static constexpr const char* name() {return "cyclicPrefixDL_t";}
+ using parent_t = CyclicPrefixDL;
+
+ };
+ cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+ cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+ struct cyclicPrefixUL_t : CyclicPrefixUL
+ {
+ static constexpr const char* name() {return "cyclicPrefixUL_t";}
+ using parent_t = CyclicPrefixUL;
+
+ };
+ cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+ cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(additionalspecialSubframePatternsExtension);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(additionalspecialSubframePatternsExtension);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ additionalspecialSubframePatternsExtension.clear();
+ cyclicPrefixDL.clear();
+ cyclicPrefixUL.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ additionalspecialSubframePatternsExtension_t additionalspecialSubframePatternsExtension;
+ cyclicPrefixDL_t cyclicPrefixDL;
+ cyclicPrefixUL_t cyclicPrefixUL;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+AerialUEsubscriptionInformation ::= ENUMERATED {
+ allowed,
+ not-allowed,
+ ...
+}
+*/
+
+struct AerialUEsubscriptionInformation : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "AerialUEsubscriptionInformation";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ allowed
+ ,not_allowed
+ } index_t;
+
+};
+
+/*
+PriorityLevel ::= INTEGER { spare (0), highest (1), lowest (14), no-priority (15) } (0..15)
+*/
+
+struct PriorityLevel : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 15>>;
+ static constexpr const char* name() {return "PriorityLevel";}
+ using parent_t = asn::integer<>;
+ enum {spare = 0, highest = 1, lowest = 14, no_priority = 15};
+
+};
+
+/*
+Pre-emptionCapability ::= ENUMERATED {
+ shall-not-trigger-pre-emption,
+ may-trigger-pre-emption
+}
+*/
+
+struct Pre_emptionCapability : asn::enumerated<2, 0, false>
+{
+ static constexpr const char* name() {return "Pre-emptionCapability";}
+ using parent_t = asn::enumerated<2, 0, false>;
+ typedef enum {
+ shall_not_trigger_pre_emption
+ ,may_trigger_pre_emption
+ } index_t;
+
+};
+
+/*
+Pre-emptionVulnerability ::= ENUMERATED {
+ not-pre-emptable,
+ pre-emptable
+}
+*/
+
+struct Pre_emptionVulnerability : asn::enumerated<2, 0, false>
+{
+ static constexpr const char* name() {return "Pre-emptionVulnerability";}
+ using parent_t = asn::enumerated<2, 0, false>;
+ typedef enum {
+ not_pre_emptable
+ ,pre_emptable
+ } index_t;
+
+};
+
+/*
+AllocationAndRetentionPriority-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct AllocationAndRetentionPriority_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+AllocationAndRetentionPriority ::= SEQUENCE {
+ priorityLevel PriorityLevel,
+ pre-emptionCapability Pre-emptionCapability,
+ pre-emptionVulnerability Pre-emptionVulnerability,
+ iE-Extensions ProtocolExtensionContainer { {AllocationAndRetentionPriority-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct AllocationAndRetentionPriority : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "AllocationAndRetentionPriority";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct priorityLevel_t : PriorityLevel
+ {
+ static constexpr const char* name() {return "priorityLevel_t";}
+ using parent_t = PriorityLevel;
+
+ };
+ priorityLevel_t& ref_priorityLevel() {return priorityLevel;}
+ priorityLevel_t const& ref_priorityLevel() const {return priorityLevel;}
+ struct pre_emptionCapability_t : Pre_emptionCapability
+ {
+ static constexpr const char* name() {return "pre_emptionCapability_t";}
+ using parent_t = Pre_emptionCapability;
+
+ };
+ pre_emptionCapability_t& ref_pre_emptionCapability() {return pre_emptionCapability;}
+ pre_emptionCapability_t const& ref_pre_emptionCapability() const {return pre_emptionCapability;}
+ struct pre_emptionVulnerability_t : Pre_emptionVulnerability
+ {
+ static constexpr const char* name() {return "pre_emptionVulnerability_t";}
+ using parent_t = Pre_emptionVulnerability;
+
+ };
+ pre_emptionVulnerability_t& ref_pre_emptionVulnerability() {return pre_emptionVulnerability;}
+ pre_emptionVulnerability_t const& ref_pre_emptionVulnerability() const {return pre_emptionVulnerability;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(priorityLevel);
+ v(pre_emptionCapability);
+ v(pre_emptionVulnerability);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(priorityLevel);
+ v(pre_emptionCapability);
+ v(pre_emptionVulnerability);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ priorityLevel.clear();
+ pre_emptionCapability.clear();
+ pre_emptionVulnerability.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ priorityLevel_t priorityLevel;
+ pre_emptionCapability_t pre_emptionCapability;
+ pre_emptionVulnerability_t pre_emptionVulnerability;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PLMN-Identity ::= OCTET STRING (SIZE(3))
+*/
+
+struct PLMN_Identity : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<3>>;
+ static constexpr const char* name() {return "PLMN-Identity";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+EUTRANCellIdentifier ::= BIT STRING (SIZE (28))
+*/
+
+struct EUTRANCellIdentifier : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<28>>;
+ static constexpr const char* name() {return "EUTRANCellIdentifier";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+ECGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ECGI_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ECGI ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ eUTRANcellIdentifier EUTRANCellIdentifier,
+ iE-Extensions ProtocolExtensionContainer { {ECGI-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ECGI : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ECGI";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct eUTRANcellIdentifier_t : EUTRANCellIdentifier
+ {
+ static constexpr const char* name() {return "eUTRANcellIdentifier_t";}
+ using parent_t = EUTRANCellIdentifier;
+
+ };
+ eUTRANcellIdentifier_t& ref_eUTRANcellIdentifier() {return eUTRANcellIdentifier;}
+ eUTRANcellIdentifier_t const& ref_eUTRANcellIdentifier() const {return eUTRANcellIdentifier;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ECGI_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ECGI_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(eUTRANcellIdentifier);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(eUTRANcellIdentifier);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ eUTRANcellIdentifier.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ eUTRANcellIdentifier_t eUTRANcellIdentifier;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CellIdListforMDT ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF ECGI
+*/
+
+struct CellIdListforMDT_elm : ECGI
+{
+ static constexpr const char* name() {return "CellIdListforMDT_elm";}
+ using parent_t = ECGI;
+
+};
+struct CellIdListforMDT : asn::sequenceof<CellIdListforMDT_elm>
+{
+ static constexpr const char* name() {return "CellIdListforMDT";}
+ using parent_t = asn::sequenceof<CellIdListforMDT_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofCellIDforMDT >>;
+
+};
+/*
+CellBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CellBasedMDT_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CellBasedMDT::= SEQUENCE {
+ cellIdListforMDT CellIdListforMDT,
+ iE-Extensions ProtocolExtensionContainer { {CellBasedMDT-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CellBasedMDT : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "CellBasedMDT";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct cellIdListforMDT_t : CellIdListforMDT
+ {
+ static constexpr const char* name() {return "cellIdListforMDT_t";}
+ using parent_t = CellIdListforMDT;
+
+ };
+ cellIdListforMDT_t& ref_cellIdListforMDT() {return cellIdListforMDT;}
+ cellIdListforMDT_t const& ref_cellIdListforMDT() const {return cellIdListforMDT;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedMDT_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CellBasedMDT_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(cellIdListforMDT);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(cellIdListforMDT);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ cellIdListforMDT.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ cellIdListforMDT_t cellIdListforMDT;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TAC ::= OCTET STRING (SIZE (2))
+*/
+
+struct TAC : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<2>>;
+ static constexpr const char* name() {return "TAC";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+TAListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAC
+*/
+
+struct TAListforMDT_elm : TAC
+{
+ static constexpr const char* name() {return "TAListforMDT_elm";}
+ using parent_t = TAC;
+
+};
+struct TAListforMDT : asn::sequenceof<TAListforMDT_elm>
+{
+ static constexpr const char* name() {return "TAListforMDT";}
+ using parent_t = asn::sequenceof<TAListforMDT_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforMDT >>;
+
+};
+/*
+TABasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct TABasedMDT_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TABasedMDT::= SEQUENCE {
+ tAListforMDT TAListforMDT,
+ iE-Extensions ProtocolExtensionContainer { {TABasedMDT-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TABasedMDT : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "TABasedMDT";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct tAListforMDT_t : TAListforMDT
+ {
+ static constexpr const char* name() {return "tAListforMDT_t";}
+ using parent_t = TAListforMDT;
+
+ };
+ tAListforMDT_t& ref_tAListforMDT() {return tAListforMDT;}
+ tAListforMDT_t const& ref_tAListforMDT() const {return tAListforMDT;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TABasedMDT_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TABasedMDT_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(tAListforMDT);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(tAListforMDT);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ tAListforMDT.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ tAListforMDT_t tAListforMDT;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TAI-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct TAI_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TAI-Item ::= SEQUENCE {
+ tAC TAC,
+ pLMN-Identity PLMN-Identity,
+ iE-Extensions ProtocolExtensionContainer { {TAI-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TAI_Item : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "TAI-Item";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct tAC_t : TAC
+ {
+ static constexpr const char* name() {return "tAC_t";}
+ using parent_t = TAC;
+
+ };
+ tAC_t& ref_tAC() {return tAC;}
+ tAC_t const& ref_tAC() const {return tAC;}
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TAI_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TAI_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(tAC);
+ v(pLMN_Identity);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(tAC);
+ v(pLMN_Identity);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ tAC.clear();
+ pLMN_Identity.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ tAC_t tAC;
+ pLMN_Identity_t pLMN_Identity;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TAIListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAI-Item
+*/
+
+struct TAIListforMDT_elm : TAI_Item
+{
+ static constexpr const char* name() {return "TAIListforMDT_elm";}
+ using parent_t = TAI_Item;
+
+};
+struct TAIListforMDT : asn::sequenceof<TAIListforMDT_elm>
+{
+ static constexpr const char* name() {return "TAIListforMDT";}
+ using parent_t = asn::sequenceof<TAIListforMDT_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforMDT >>;
+
+};
+/*
+TAIBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct TAIBasedMDT_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TAIBasedMDT ::= SEQUENCE {
+ tAIListforMDT TAIListforMDT,
+ iE-Extensions ProtocolExtensionContainer { {TAIBasedMDT-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TAIBasedMDT : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "TAIBasedMDT";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct tAIListforMDT_t : TAIListforMDT
+ {
+ static constexpr const char* name() {return "tAIListforMDT_t";}
+ using parent_t = TAIListforMDT;
+
+ };
+ tAIListforMDT_t& ref_tAIListforMDT() {return tAIListforMDT;}
+ tAIListforMDT_t const& ref_tAIListforMDT() const {return tAIListforMDT;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(tAIListforMDT);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(tAIListforMDT);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ tAIListforMDT.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ tAIListforMDT_t tAIListforMDT;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+AreaScopeOfMDT ::= CHOICE {
+ cellBased CellBasedMDT,
+ tABased TABasedMDT,
+ pLMNWide NULL,
+ ...,
+ tAIBased TAIBasedMDT
+}
+*/
+
+struct AreaScopeOfMDT : asn::choice<4, 1, true>
+{
+ static constexpr const char* name() {return "AreaScopeOfMDT";}
+ using parent_t = asn::choice<4, 1, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~AreaScopeOfMDT() {clear();}
+ struct cellBased_t : CellBasedMDT
+ {
+ static constexpr const char* name() {return "cellBased_t";}
+ using parent_t = CellBasedMDT;
+
+ };
+ struct tABased_t : TABasedMDT
+ {
+ static constexpr const char* name() {return "tABased_t";}
+ using parent_t = TABasedMDT;
+
+ };
+ struct pLMNWide_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "pLMNWide_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ struct tAIBased_t : TAIBasedMDT
+ {
+ static constexpr const char* name() {return "tAIBased_t";}
+ using parent_t = TAIBasedMDT;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<cellBased_t>(); break;
+ case 2: var.destroy<tABased_t>(); break;
+ case 3: var.destroy<pLMNWide_t>(); break;
+ case 4: var.destroy<tAIBased_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<cellBased_t>());
+ case 2: set_index(2); return v(var.build<tABased_t>());
+ case 3: set_index(3); return v(var.build<pLMNWide_t>());
+ case 4: set_index(4); return v(var.build<tAIBased_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<cellBased_t>());
+ case 2: return v(var.as<tABased_t>());
+ case 3: return v(var.as<pLMNWide_t>());
+ case 4: return v(var.as<tAIBased_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<cellBased_t>(1);
+ v.template operator()<tABased_t>(2);
+ v.template operator()<pLMNWide_t>(3);
+ v.template operator()<tAIBased_t>(4);
+
+ }
+ cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
+ cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
+ tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
+ tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
+ pLMNWide_t& select_pLMNWide() { if(get_index() != 3) { clear(); set_index(3); return var.build<pLMNWide_t>();} return var.as<pLMNWide_t>();}
+ pLMNWide_t const* get_pLMNWide() const { if(get_index() == 3) { return &var.as<pLMNWide_t>();} return nullptr; }
+ tAIBased_t& select_tAIBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
+ tAIBased_t const* get_tAIBased() const { if(get_index() == 4) { return &var.as<tAIBased_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(cellBased_t)];
+ char dummy2[sizeof(tABased_t)];
+ char dummy3[sizeof(pLMNWide_t)];
+ char dummy4[sizeof(tAIBased_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+CellIdListforQMC ::= SEQUENCE (SIZE(1..maxnoofCellIDforQMC)) OF ECGI
+*/
+
+struct CellIdListforQMC_elm : ECGI
+{
+ static constexpr const char* name() {return "CellIdListforQMC_elm";}
+ using parent_t = ECGI;
+
+};
+struct CellIdListforQMC : asn::sequenceof<CellIdListforQMC_elm>
+{
+ static constexpr const char* name() {return "CellIdListforQMC";}
+ using parent_t = asn::sequenceof<CellIdListforQMC_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofCellIDforQMC >>;
+
+};
+/*
+CellBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CellBasedQMC_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CellBasedQMC::= SEQUENCE {
+ cellIdListforQMC CellIdListforQMC,
+ iE-Extensions ProtocolExtensionContainer { {CellBasedQMC-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CellBasedQMC : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "CellBasedQMC";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct cellIdListforQMC_t : CellIdListforQMC
+ {
+ static constexpr const char* name() {return "cellIdListforQMC_t";}
+ using parent_t = CellIdListforQMC;
+
+ };
+ cellIdListforQMC_t& ref_cellIdListforQMC() {return cellIdListforQMC;}
+ cellIdListforQMC_t const& ref_cellIdListforQMC() const {return cellIdListforQMC;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedQMC_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CellBasedQMC_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(cellIdListforQMC);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(cellIdListforQMC);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ cellIdListforQMC.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ cellIdListforQMC_t cellIdListforQMC;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TAListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAC
+*/
+
+struct TAListforQMC_elm : TAC
+{
+ static constexpr const char* name() {return "TAListforQMC_elm";}
+ using parent_t = TAC;
+
+};
+struct TAListforQMC : asn::sequenceof<TAListforQMC_elm>
+{
+ static constexpr const char* name() {return "TAListforQMC";}
+ using parent_t = asn::sequenceof<TAListforQMC_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforQMC >>;
+
+};
+/*
+TABasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct TABasedQMC_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TABasedQMC ::= SEQUENCE {
+ tAListforQMC TAListforQMC,
+ iE-Extensions ProtocolExtensionContainer { {TABasedQMC-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TABasedQMC : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "TABasedQMC";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct tAListforQMC_t : TAListforQMC
+ {
+ static constexpr const char* name() {return "tAListforQMC_t";}
+ using parent_t = TAListforQMC;
+
+ };
+ tAListforQMC_t& ref_tAListforQMC() {return tAListforQMC;}
+ tAListforQMC_t const& ref_tAListforQMC() const {return tAListforQMC;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TABasedQMC_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TABasedQMC_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(tAListforQMC);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(tAListforQMC);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ tAListforQMC.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ tAListforQMC_t tAListforQMC;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TAIListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAI-Item
+*/
+
+struct TAIListforQMC_elm : TAI_Item
+{
+ static constexpr const char* name() {return "TAIListforQMC_elm";}
+ using parent_t = TAI_Item;
+
+};
+struct TAIListforQMC : asn::sequenceof<TAIListforQMC_elm>
+{
+ static constexpr const char* name() {return "TAIListforQMC";}
+ using parent_t = asn::sequenceof<TAIListforQMC_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforQMC >>;
+
+};
+/*
+TAIBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct TAIBasedQMC_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TAIBasedQMC ::= SEQUENCE {
+ tAIListforQMC TAIListforQMC,
+ iE-Extensions ProtocolExtensionContainer { {TAIBasedQMC-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TAIBasedQMC : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "TAIBasedQMC";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct tAIListforQMC_t : TAIListforQMC
+ {
+ static constexpr const char* name() {return "tAIListforQMC_t";}
+ using parent_t = TAIListforQMC;
+
+ };
+ tAIListforQMC_t& ref_tAIListforQMC() {return tAIListforQMC;}
+ tAIListforQMC_t const& ref_tAIListforQMC() const {return tAIListforQMC;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(tAIListforQMC);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(tAIListforQMC);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ tAIListforQMC.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ tAIListforQMC_t tAIListforQMC;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PLMNListforQMC ::= SEQUENCE (SIZE(1..maxnoofPLMNforQMC)) OF PLMN-Identity
+*/
+
+struct PLMNListforQMC_elm : PLMN_Identity
+{
+ static constexpr const char* name() {return "PLMNListforQMC_elm";}
+ using parent_t = PLMN_Identity;
+
+};
+struct PLMNListforQMC : asn::sequenceof<PLMNListforQMC_elm>
+{
+ static constexpr const char* name() {return "PLMNListforQMC";}
+ using parent_t = asn::sequenceof<PLMNListforQMC_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofPLMNforQMC >>;
+
+};
+/*
+PLMNAreaBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct PLMNAreaBasedQMC_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+PLMNAreaBasedQMC ::= SEQUENCE {
+ plmnListforQMC PLMNListforQMC,
+ iE-Extensions ProtocolExtensionContainer { {PLMNAreaBasedQMC-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct PLMNAreaBasedQMC : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "PLMNAreaBasedQMC";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct plmnListforQMC_t : PLMNListforQMC
+ {
+ static constexpr const char* name() {return "plmnListforQMC_t";}
+ using parent_t = PLMNListforQMC;
+
+ };
+ plmnListforQMC_t& ref_plmnListforQMC() {return plmnListforQMC;}
+ plmnListforQMC_t const& ref_plmnListforQMC() const {return plmnListforQMC;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(plmnListforQMC);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(plmnListforQMC);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ plmnListforQMC.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ plmnListforQMC_t plmnListforQMC;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+AreaScopeOfQMC ::= CHOICE {
+ cellBased CellBasedQMC,
+ tABased TABasedQMC,
+ tAIBased TAIBasedQMC,
+ pLMNAreaBased PLMNAreaBasedQMC,
+ ...
+}
+*/
+
+struct AreaScopeOfQMC : asn::choice<4, 0, true>
+{
+ static constexpr const char* name() {return "AreaScopeOfQMC";}
+ using parent_t = asn::choice<4, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~AreaScopeOfQMC() {clear();}
+ struct cellBased_t : CellBasedQMC
+ {
+ static constexpr const char* name() {return "cellBased_t";}
+ using parent_t = CellBasedQMC;
+
+ };
+ struct tABased_t : TABasedQMC
+ {
+ static constexpr const char* name() {return "tABased_t";}
+ using parent_t = TABasedQMC;
+
+ };
+ struct tAIBased_t : TAIBasedQMC
+ {
+ static constexpr const char* name() {return "tAIBased_t";}
+ using parent_t = TAIBasedQMC;
+
+ };
+ struct pLMNAreaBased_t : PLMNAreaBasedQMC
+ {
+ static constexpr const char* name() {return "pLMNAreaBased_t";}
+ using parent_t = PLMNAreaBasedQMC;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<cellBased_t>(); break;
+ case 2: var.destroy<tABased_t>(); break;
+ case 3: var.destroy<tAIBased_t>(); break;
+ case 4: var.destroy<pLMNAreaBased_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<cellBased_t>());
+ case 2: set_index(2); return v(var.build<tABased_t>());
+ case 3: set_index(3); return v(var.build<tAIBased_t>());
+ case 4: set_index(4); return v(var.build<pLMNAreaBased_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<cellBased_t>());
+ case 2: return v(var.as<tABased_t>());
+ case 3: return v(var.as<tAIBased_t>());
+ case 4: return v(var.as<pLMNAreaBased_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<cellBased_t>(1);
+ v.template operator()<tABased_t>(2);
+ v.template operator()<tAIBased_t>(3);
+ v.template operator()<pLMNAreaBased_t>(4);
+
+ }
+ cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
+ cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
+ tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
+ tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
+ tAIBased_t& select_tAIBased() { if(get_index() != 3) { clear(); set_index(3); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
+ tAIBased_t const* get_tAIBased() const { if(get_index() == 3) { return &var.as<tAIBased_t>();} return nullptr; }
+ pLMNAreaBased_t& select_pLMNAreaBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<pLMNAreaBased_t>();} return var.as<pLMNAreaBased_t>();}
+ pLMNAreaBased_t const* get_pLMNAreaBased() const { if(get_index() == 4) { return &var.as<pLMNAreaBased_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(cellBased_t)];
+ char dummy2[sizeof(tABased_t)];
+ char dummy3[sizeof(tAIBased_t)];
+ char dummy4[sizeof(pLMNAreaBased_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+FreqBandIndicator ::= INTEGER (1..256, ...)
+*/
+
+struct FreqBandIndicator : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 256>>;
+ static constexpr const char* name() {return "FreqBandIndicator";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+BandInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct BandInfo_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+BandInfo ::= SEQUENCE {
+ freqBandIndicator FreqBandIndicator,
+ iE-Extensions ProtocolExtensionContainer { {BandInfo-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct BandInfo : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "BandInfo";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct freqBandIndicator_t : FreqBandIndicator
+ {
+ static constexpr const char* name() {return "freqBandIndicator_t";}
+ using parent_t = FreqBandIndicator;
+
+ };
+ freqBandIndicator_t& ref_freqBandIndicator() {return freqBandIndicator;}
+ freqBandIndicator_t const& ref_freqBandIndicator() const {return freqBandIndicator;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<BandInfo_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<BandInfo_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(freqBandIndicator);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(freqBandIndicator);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ freqBandIndicator.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ freqBandIndicator_t freqBandIndicator;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+BandwidthReducedSI::= ENUMERATED {
+ scheduled,
+ ...
+}
+*/
+
+struct BandwidthReducedSI : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "BandwidthReducedSI";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ scheduled
+ } index_t;
+
+};
+
+/*
+BearerType ::= ENUMERATED {
+ non-IP,
+ ...
+}
+*/
+
+struct BearerType : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "BearerType";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ non_IP
+ } index_t;
+
+};
+
+/*
+BenefitMetric ::= INTEGER (-101..100, ...)
+*/
+
+struct BenefitMetric : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<-101, 100>>;
+ static constexpr const char* name() {return "BenefitMetric";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+BitRate ::= INTEGER (0..10000000000)
+*/
+
+struct BitRate : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 10000000000>>;
+ static constexpr const char* name() {return "BitRate";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+BluetoothMeasConfig::= ENUMERATED {setup,...}
+*/
+
+struct BluetoothMeasConfig : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "BluetoothMeasConfig";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ setup
+ } index_t;
+
+};
+
+/*
+BluetoothName ::= OCTET STRING (SIZE (1..248))
+*/
+
+struct BluetoothName : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 248>>;
+ static constexpr const char* name() {return "BluetoothName";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+BluetoothMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofBluetoothName)) OF BluetoothName
+*/
+
+struct BluetoothMeasConfigNameList_elm : BluetoothName
+{
+ static constexpr const char* name() {return "BluetoothMeasConfigNameList_elm";}
+ using parent_t = BluetoothName;
+
+};
+struct BluetoothMeasConfigNameList : asn::sequenceof<BluetoothMeasConfigNameList_elm>
+{
+ static constexpr const char* name() {return "BluetoothMeasConfigNameList";}
+ using parent_t = asn::sequenceof<BluetoothMeasConfigNameList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofBluetoothName >>;
+
+};
+/*
+BluetoothMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct BluetoothMeasurementConfiguration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+BluetoothMeasurementConfiguration ::= SEQUENCE {
+ bluetoothMeasConfig BluetoothMeasConfig,
+ bluetoothMeasConfigNameList BluetoothMeasConfigNameList OPTIONAL,
+ bt-rssi ENUMERATED {true, ...} OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {BluetoothMeasurementConfiguration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct BluetoothMeasurementConfiguration : asn::sequence<4, 0, true, 3>
+{
+ static constexpr const char* name() {return "BluetoothMeasurementConfiguration";}
+ using parent_t = asn::sequence<4, 0, true, 3>;
+ struct bluetoothMeasConfig_t : BluetoothMeasConfig
+ {
+ static constexpr const char* name() {return "bluetoothMeasConfig_t";}
+ using parent_t = BluetoothMeasConfig;
+
+ };
+ bluetoothMeasConfig_t& ref_bluetoothMeasConfig() {return bluetoothMeasConfig;}
+ bluetoothMeasConfig_t const& ref_bluetoothMeasConfig() const {return bluetoothMeasConfig;}
+ struct bluetoothMeasConfigNameList_t : BluetoothMeasConfigNameList
+ {
+ static constexpr const char* name() {return "bluetoothMeasConfigNameList_t";}
+ using parent_t = BluetoothMeasConfigNameList;
+ static constexpr bool optional = true;
+
+ };
+ bluetoothMeasConfigNameList_t& set_bluetoothMeasConfigNameList() { bluetoothMeasConfigNameList.setpresent(true); return bluetoothMeasConfigNameList;}
+ bluetoothMeasConfigNameList_t const* get_bluetoothMeasConfigNameList() const {return bluetoothMeasConfigNameList.is_valid() ? &bluetoothMeasConfigNameList : nullptr;}
+ struct bt_rssi_t : asn::enumerated<1, 0, true>
+ {
+ static constexpr const char* name() {return "bt_rssi_t";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ True
+ } index_t;
+
+ };
+
+ bt_rssi_t& set_bt_rssi() { bt_rssi.setpresent(true); return bt_rssi;}
+ bt_rssi_t const* get_bt_rssi() const {return bt_rssi.is_valid() ? &bt_rssi : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(bluetoothMeasConfig);
+ v(bluetoothMeasConfigNameList);
+ v(bt_rssi);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(bluetoothMeasConfig);
+ v(bluetoothMeasConfigNameList);
+ v(bt_rssi);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ bluetoothMeasConfig.clear();
+ bluetoothMeasConfigNameList.clear();
+ bt_rssi.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ bluetoothMeasConfig_t bluetoothMeasConfig;
+ bluetoothMeasConfigNameList_t bluetoothMeasConfigNameList;
+ bt_rssi_t bt_rssi;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+BroadcastPLMNs-Item ::= SEQUENCE (SIZE(1..maxnoofBPLMNs)) OF PLMN-Identity
+*/
+
+struct BroadcastPLMNs_Item_elm : PLMN_Identity
+{
+ static constexpr const char* name() {return "BroadcastPLMNs_Item_elm";}
+ using parent_t = PLMN_Identity;
+
+};
+struct BroadcastPLMNs_Item : asn::sequenceof<BroadcastPLMNs_Item_elm>
+{
+ static constexpr const char* name() {return "BroadcastPLMNs-Item";}
+ using parent_t = asn::sequenceof<BroadcastPLMNs_Item_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofBPLMNs >>;
+
+};
+/*
+CNTypeRestrictionsItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CNTypeRestrictionsItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CNTypeRestrictionsItem ::= SEQUENCE {
+ plmn-Id PLMN-Identity,
+ cn-type ENUMERATED {fiveGC-forbidden, ...},
+ iE-Extensions ProtocolExtensionContainer { {CNTypeRestrictionsItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CNTypeRestrictionsItem : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CNTypeRestrictionsItem";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct plmn_Id_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "plmn_Id_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ plmn_Id_t& ref_plmn_Id() {return plmn_Id;}
+ plmn_Id_t const& ref_plmn_Id() const {return plmn_Id;}
+ struct cn_type_t : asn::enumerated<1, 0, true>
+ {
+ static constexpr const char* name() {return "cn_type_t";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ fiveGC_forbidden
+ } index_t;
+
+ };
+
+ cn_type_t& ref_cn_type() {return cn_type;}
+ cn_type_t const& ref_cn_type() const {return cn_type;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(plmn_Id);
+ v(cn_type);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(plmn_Id);
+ v(cn_type);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ plmn_Id.clear();
+ cn_type.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ plmn_Id_t plmn_Id;
+ cn_type_t cn_type;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CNTypeRestrictions ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF CNTypeRestrictionsItem
+*/
+
+struct CNTypeRestrictions_elm : CNTypeRestrictionsItem
+{
+ static constexpr const char* name() {return "CNTypeRestrictions_elm";}
+ using parent_t = CNTypeRestrictionsItem;
+
+};
+struct CNTypeRestrictions : asn::sequenceof<CNTypeRestrictions_elm>
+{
+ static constexpr const char* name() {return "CNTypeRestrictions";}
+ using parent_t = asn::sequenceof<CNTypeRestrictions_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+PDCP-SNExtended ::= INTEGER (0..32767)
+*/
+
+struct PDCP_SNExtended : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 32767>>;
+ static constexpr const char* name() {return "PDCP-SNExtended";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+HFNModified ::= INTEGER (0..131071)
+*/
+
+struct HFNModified : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 131071>>;
+ static constexpr const char* name() {return "HFNModified";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTValueExtended-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct COUNTValueExtended_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+COUNTValueExtended ::= SEQUENCE {
+ pDCP-SNExtended PDCP-SNExtended,
+ hFNModified HFNModified,
+ iE-Extensions ProtocolExtensionContainer { {COUNTValueExtended-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct COUNTValueExtended : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "COUNTValueExtended";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pDCP_SNExtended_t : PDCP_SNExtended
+ {
+ static constexpr const char* name() {return "pDCP_SNExtended_t";}
+ using parent_t = PDCP_SNExtended;
+
+ };
+ pDCP_SNExtended_t& ref_pDCP_SNExtended() {return pDCP_SNExtended;}
+ pDCP_SNExtended_t const& ref_pDCP_SNExtended() const {return pDCP_SNExtended;}
+ struct hFNModified_t : HFNModified
+ {
+ static constexpr const char* name() {return "hFNModified_t";}
+ using parent_t = HFNModified;
+
+ };
+ hFNModified_t& ref_hFNModified() {return hFNModified;}
+ hFNModified_t const& ref_hFNModified() const {return hFNModified;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pDCP_SNExtended);
+ v(hFNModified);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pDCP_SNExtended);
+ v(hFNModified);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pDCP_SNExtended.clear();
+ hFNModified.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pDCP_SNExtended_t pDCP_SNExtended;
+ hFNModified_t hFNModified;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PDCP-SN ::= INTEGER (0..4095)
+*/
+
+struct PDCP_SN : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "PDCP-SN";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+HFN ::= INTEGER (0..1048575)
+*/
+
+struct HFN : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 1048575>>;
+ static constexpr const char* name() {return "HFN";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTvalue-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct COUNTvalue_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+COUNTvalue ::= SEQUENCE {
+ pDCP-SN PDCP-SN,
+ hFN HFN,
+ iE-Extensions ProtocolExtensionContainer { {COUNTvalue-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct COUNTvalue : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "COUNTvalue";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pDCP_SN_t : PDCP_SN
+ {
+ static constexpr const char* name() {return "pDCP_SN_t";}
+ using parent_t = PDCP_SN;
+
+ };
+ pDCP_SN_t& ref_pDCP_SN() {return pDCP_SN;}
+ pDCP_SN_t const& ref_pDCP_SN() const {return pDCP_SN;}
+ struct hFN_t : HFN
+ {
+ static constexpr const char* name() {return "hFN_t";}
+ using parent_t = HFN;
+
+ };
+ hFN_t& ref_hFN() {return hFN;}
+ hFN_t const& ref_hFN() const {return hFN;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvalue_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<COUNTvalue_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pDCP_SN);
+ v(hFN);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pDCP_SN);
+ v(hFN);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pDCP_SN.clear();
+ hFN.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pDCP_SN_t pDCP_SN;
+ hFN_t hFN;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PDCP-SNlength18 ::= INTEGER (0..262143)
+*/
+
+struct PDCP_SNlength18 : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 262143>>;
+ static constexpr const char* name() {return "PDCP-SNlength18";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+HFNforPDCP-SNlength18 ::= INTEGER (0..16383)
+*/
+
+struct HFNforPDCP_SNlength18 : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 16383>>;
+ static constexpr const char* name() {return "HFNforPDCP-SNlength18";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+COUNTvaluePDCP-SNlength18-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct COUNTvaluePDCP_SNlength18_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+COUNTvaluePDCP-SNlength18 ::= SEQUENCE {
+ pDCP-SNlength18 PDCP-SNlength18,
+ hFNforPDCP-SNlength18 HFNforPDCP-SNlength18,
+ iE-Extensions ProtocolExtensionContainer { {COUNTvaluePDCP-SNlength18-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct COUNTvaluePDCP_SNlength18 : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "COUNTvaluePDCP-SNlength18";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pDCP_SNlength18_t : PDCP_SNlength18
+ {
+ static constexpr const char* name() {return "pDCP_SNlength18_t";}
+ using parent_t = PDCP_SNlength18;
+
+ };
+ pDCP_SNlength18_t& ref_pDCP_SNlength18() {return pDCP_SNlength18;}
+ pDCP_SNlength18_t const& ref_pDCP_SNlength18() const {return pDCP_SNlength18;}
+ struct hFNforPDCP_SNlength18_t : HFNforPDCP_SNlength18
+ {
+ static constexpr const char* name() {return "hFNforPDCP_SNlength18_t";}
+ using parent_t = HFNforPDCP_SNlength18;
+
+ };
+ hFNforPDCP_SNlength18_t& ref_hFNforPDCP_SNlength18() {return hFNforPDCP_SNlength18;}
+ hFNforPDCP_SNlength18_t const& ref_hFNforPDCP_SNlength18() const {return hFNforPDCP_SNlength18;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pDCP_SNlength18);
+ v(hFNforPDCP_SNlength18);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pDCP_SNlength18);
+ v(hFNforPDCP_SNlength18);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pDCP_SNlength18.clear();
+ hFNforPDCP_SNlength18.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pDCP_SNlength18_t pDCP_SNlength18;
+ hFNforPDCP_SNlength18_t hFNforPDCP_SNlength18;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CRNTI ::= BIT STRING (SIZE (16))
+*/
+
+struct CRNTI : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<16>>;
+ static constexpr const char* name() {return "CRNTI";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+CSG-Id ::= BIT STRING (SIZE (27))
+*/
+
+struct CSG_Id : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<27>>;
+ static constexpr const char* name() {return "CSG-Id";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+CSGMembershipStatus ::= ENUMERATED {
+ member,
+ not-member
+}
+*/
+
+struct CSGMembershipStatus : asn::enumerated<2, 0, false>
+{
+ static constexpr const char* name() {return "CSGMembershipStatus";}
+ using parent_t = asn::enumerated<2, 0, false>;
+ typedef enum {
+ member
+ ,not_member
+ } index_t;
+
+};
+
+/*
+UEID ::= BIT STRING (SIZE (16))
+*/
+
+struct UEID : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<16>>;
+ static constexpr const char* name() {return "UEID";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+WidebandCQICodeword1::= CHOICE {
+ four-bitCQI INTEGER (0..15, ...),
+ three-bitSpatialDifferentialCQI INTEGER (0..7, ...),
+ ...
+}
+*/
+
+struct WidebandCQICodeword1 : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "WidebandCQICodeword1";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~WidebandCQICodeword1() {clear();}
+ struct four_bitCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "four_bitCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct three_bitSpatialDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+ static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<four_bitCQI_t>(); break;
+ case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+ case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<four_bitCQI_t>());
+ case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<four_bitCQI_t>(1);
+ v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
+
+ }
+ four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+ four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+ three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
+ three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(four_bitCQI_t)];
+ char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+WidebandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct WidebandCQI_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+WidebandCQI ::= SEQUENCE {
+ widebandCQICodeword0 INTEGER (0..15, ...),
+ widebandCQICodeword1 WidebandCQICodeword1 OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {WidebandCQI-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct WidebandCQI : asn::sequence<3, 0, true, 2>
+{
+ static constexpr const char* name() {return "WidebandCQI";}
+ using parent_t = asn::sequence<3, 0, true, 2>;
+ struct widebandCQICodeword0_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "widebandCQICodeword0_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ widebandCQICodeword0_t& ref_widebandCQICodeword0() {return widebandCQICodeword0;}
+ widebandCQICodeword0_t const& ref_widebandCQICodeword0() const {return widebandCQICodeword0;}
+ struct widebandCQICodeword1_t : WidebandCQICodeword1
+ {
+ static constexpr const char* name() {return "widebandCQICodeword1_t";}
+ using parent_t = WidebandCQICodeword1;
+ static constexpr bool optional = true;
+
+ };
+ widebandCQICodeword1_t& set_widebandCQICodeword1() { widebandCQICodeword1.setpresent(true); return widebandCQICodeword1;}
+ widebandCQICodeword1_t const* get_widebandCQICodeword1() const {return widebandCQICodeword1.is_valid() ? &widebandCQICodeword1 : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<WidebandCQI_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<WidebandCQI_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(widebandCQICodeword0);
+ v(widebandCQICodeword1);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(widebandCQICodeword0);
+ v(widebandCQICodeword1);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ widebandCQICodeword0.clear();
+ widebandCQICodeword1.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ widebandCQICodeword0_t widebandCQICodeword0;
+ widebandCQICodeword1_t widebandCQICodeword1;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SubbandSize ::= ENUMERATED {
+ size2,
+ size3,
+ size4,
+ size6,
+ size8,
+ ...
+}
+*/
+
+struct SubbandSize : asn::enumerated<5, 0, true>
+{
+ static constexpr const char* name() {return "SubbandSize";}
+ using parent_t = asn::enumerated<5, 0, true>;
+ typedef enum {
+ size2
+ ,size3
+ ,size4
+ ,size6
+ ,size8
+ } index_t;
+
+};
+
+/*
+SubbandCQICodeword0 ::= CHOICE {
+ four-bitCQI INTEGER (0..15, ...),
+ two-bitSubbandDifferentialCQI INTEGER (0..3, ...),
+ two-bitDifferentialCQI INTEGER (0..3, ...),
+ ...
+}
+*/
+
+struct SubbandCQICodeword0 : asn::choice<3, 0, true>
+{
+ static constexpr const char* name() {return "SubbandCQICodeword0";}
+ using parent_t = asn::choice<3, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 4;}
+ void set_unknown() { set_index(4); }
+ ~SubbandCQICodeword0() {clear();}
+ struct four_bitCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "four_bitCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct two_bitSubbandDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+ static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct two_bitDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+ static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<four_bitCQI_t>(); break;
+ case 2: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
+ case 3: var.destroy<two_bitDifferentialCQI_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+ case 2: set_index(2); return v(var.build<two_bitSubbandDifferentialCQI_t>());
+ case 3: set_index(3); return v(var.build<two_bitDifferentialCQI_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<four_bitCQI_t>());
+ case 2: return v(var.as<two_bitSubbandDifferentialCQI_t>());
+ case 3: return v(var.as<two_bitDifferentialCQI_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<four_bitCQI_t>(1);
+ v.template operator()<two_bitSubbandDifferentialCQI_t>(2);
+ v.template operator()<two_bitDifferentialCQI_t>(3);
+
+ }
+ four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+ four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+ two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
+ two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 2) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
+ two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
+ two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(four_bitCQI_t)];
+ char dummy2[sizeof(two_bitSubbandDifferentialCQI_t)];
+ char dummy3[sizeof(two_bitDifferentialCQI_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+SubbandCQICodeword1 ::= CHOICE {
+ four-bitCQI INTEGER (0..15, ...),
+ three-bitSpatialDifferentialCQI INTEGER (0..7, ...),
+ two-bitSubbandDifferentialCQI INTEGER (0..3, ...),
+ two-bitDifferentialCQI INTEGER (0..3, ...),
+ ...
+}
+*/
+
+struct SubbandCQICodeword1 : asn::choice<4, 0, true>
+{
+ static constexpr const char* name() {return "SubbandCQICodeword1";}
+ using parent_t = asn::choice<4, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~SubbandCQICodeword1() {clear();}
+ struct four_bitCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "four_bitCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct three_bitSpatialDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+ static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct two_bitSubbandDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+ static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ struct two_bitDifferentialCQI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+ static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<four_bitCQI_t>(); break;
+ case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
+ case 3: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
+ case 4: var.destroy<two_bitDifferentialCQI_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<four_bitCQI_t>());
+ case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
+ case 3: set_index(3); return v(var.build<two_bitSubbandDifferentialCQI_t>());
+ case 4: set_index(4); return v(var.build<two_bitDifferentialCQI_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<four_bitCQI_t>());
+ case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
+ case 3: return v(var.as<two_bitSubbandDifferentialCQI_t>());
+ case 4: return v(var.as<two_bitDifferentialCQI_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<four_bitCQI_t>(1);
+ v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
+ v.template operator()<two_bitSubbandDifferentialCQI_t>(3);
+ v.template operator()<two_bitDifferentialCQI_t>(4);
+
+ }
+ four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
+ four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
+ three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
+ three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
+ two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
+ two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
+ two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 4) { clear(); set_index(4); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
+ two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 4) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(four_bitCQI_t)];
+ char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
+ char dummy3[sizeof(two_bitSubbandDifferentialCQI_t)];
+ char dummy4[sizeof(two_bitDifferentialCQI_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+SubbandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SubbandCQI_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SubbandCQI ::= SEQUENCE {
+ subbandCQICodeword0 SubbandCQICodeword0,
+ subbandCQICodeword1 SubbandCQICodeword1 OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {SubbandCQI-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SubbandCQI : asn::sequence<3, 0, true, 2>
+{
+ static constexpr const char* name() {return "SubbandCQI";}
+ using parent_t = asn::sequence<3, 0, true, 2>;
+ struct subbandCQICodeword0_t : SubbandCQICodeword0
+ {
+ static constexpr const char* name() {return "subbandCQICodeword0_t";}
+ using parent_t = SubbandCQICodeword0;
+
+ };
+ subbandCQICodeword0_t& ref_subbandCQICodeword0() {return subbandCQICodeword0;}
+ subbandCQICodeword0_t const& ref_subbandCQICodeword0() const {return subbandCQICodeword0;}
+ struct subbandCQICodeword1_t : SubbandCQICodeword1
+ {
+ static constexpr const char* name() {return "subbandCQICodeword1_t";}
+ using parent_t = SubbandCQICodeword1;
+ static constexpr bool optional = true;
+
+ };
+ subbandCQICodeword1_t& set_subbandCQICodeword1() { subbandCQICodeword1.setpresent(true); return subbandCQICodeword1;}
+ subbandCQICodeword1_t const* get_subbandCQICodeword1() const {return subbandCQICodeword1.is_valid() ? &subbandCQICodeword1 : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQI_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SubbandCQI_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(subbandCQICodeword0);
+ v(subbandCQICodeword1);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(subbandCQICodeword0);
+ v(subbandCQICodeword1);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ subbandCQICodeword0.clear();
+ subbandCQICodeword1.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ subbandCQICodeword0_t subbandCQICodeword0;
+ subbandCQICodeword1_t subbandCQICodeword1;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SubbandCQIItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SubbandCQIItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SubbandCQIItem ::= SEQUENCE {
+ subbandCQI SubbandCQI,
+ subbandIndex INTEGER (0..27,...),
+ iE-Extensions ProtocolExtensionContainer { {SubbandCQIItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SubbandCQIItem : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "SubbandCQIItem";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct subbandCQI_t : SubbandCQI
+ {
+ static constexpr const char* name() {return "subbandCQI_t";}
+ using parent_t = SubbandCQI;
+
+ };
+ subbandCQI_t& ref_subbandCQI() {return subbandCQI;}
+ subbandCQI_t const& ref_subbandCQI() const {return subbandCQI;}
+ struct subbandIndex_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 27>>;
+ static constexpr const char* name() {return "subbandIndex_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ subbandIndex_t& ref_subbandIndex() {return subbandIndex;}
+ subbandIndex_t const& ref_subbandIndex() const {return subbandIndex;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(subbandCQI);
+ v(subbandIndex);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(subbandCQI);
+ v(subbandIndex);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ subbandCQI.clear();
+ subbandIndex.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ subbandCQI_t subbandCQI;
+ subbandIndex_t subbandIndex;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SubbandCQIList ::= SEQUENCE (SIZE(1.. maxSubband)) OF SubbandCQIItem
+*/
+
+struct SubbandCQIList_elm : SubbandCQIItem
+{
+ static constexpr const char* name() {return "SubbandCQIList_elm";}
+ using parent_t = SubbandCQIItem;
+
+};
+struct SubbandCQIList : asn::sequenceof<SubbandCQIList_elm>
+{
+ static constexpr const char* name() {return "SubbandCQIList";}
+ using parent_t = asn::sequenceof<SubbandCQIList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxSubband >>;
+
+};
+/*
+CSIReportPerCSIProcessItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CSIReportPerCSIProcessItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CSIReportPerCSIProcessItem ::= SEQUENCE (SIZE(1.. maxCSIReport)) OF
+ SEQUENCE {
+ rI INTEGER (1..8, ...),
+ widebandCQI WidebandCQI,
+ subbandSize SubbandSize,
+ subbandCQIList SubbandCQIList OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {CSIReportPerCSIProcessItem-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct CSIReportPerCSIProcessItem_elm : asn::sequence<5, 0, true, 2>
+{
+ static constexpr const char* name() {return "CSIReportPerCSIProcessItem_elm";}
+ using parent_t = asn::sequence<5, 0, true, 2>;
+ struct rI_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 8>>;
+ static constexpr const char* name() {return "rI_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ rI_t& ref_rI() {return rI;}
+ rI_t const& ref_rI() const {return rI;}
+ struct widebandCQI_t : WidebandCQI
+ {
+ static constexpr const char* name() {return "widebandCQI_t";}
+ using parent_t = WidebandCQI;
+
+ };
+ widebandCQI_t& ref_widebandCQI() {return widebandCQI;}
+ widebandCQI_t const& ref_widebandCQI() const {return widebandCQI;}
+ struct subbandSize_t : SubbandSize
+ {
+ static constexpr const char* name() {return "subbandSize_t";}
+ using parent_t = SubbandSize;
+
+ };
+ subbandSize_t& ref_subbandSize() {return subbandSize;}
+ subbandSize_t const& ref_subbandSize() const {return subbandSize;}
+ struct subbandCQIList_t : SubbandCQIList
+ {
+ static constexpr const char* name() {return "subbandCQIList_t";}
+ using parent_t = SubbandCQIList;
+ static constexpr bool optional = true;
+
+ };
+ subbandCQIList_t& set_subbandCQIList() { subbandCQIList.setpresent(true); return subbandCQIList;}
+ subbandCQIList_t const* get_subbandCQIList() const {return subbandCQIList.is_valid() ? &subbandCQIList : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rI);
+ v(widebandCQI);
+ v(subbandSize);
+ v(subbandCQIList);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rI);
+ v(widebandCQI);
+ v(subbandSize);
+ v(subbandCQIList);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rI.clear();
+ widebandCQI.clear();
+ subbandSize.clear();
+ subbandCQIList.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rI_t rI;
+ widebandCQI_t widebandCQI;
+ subbandSize_t subbandSize;
+ subbandCQIList_t subbandCQIList;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CSIReportPerCSIProcessItem : asn::sequenceof<CSIReportPerCSIProcessItem_elm>
+{
+ static constexpr const char* name() {return "CSIReportPerCSIProcessItem";}
+ using parent_t = asn::sequenceof<CSIReportPerCSIProcessItem_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCSIReport >>;
+
+};
+/*
+CSIReportPerCSIProcess-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CSIReportPerCSIProcess_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CSIReportPerCSIProcess ::= SEQUENCE (SIZE(1.. maxCSIProcess)) OF
+ SEQUENCE {
+ cSIProcessConfigurationIndex INTEGER (1..7, ...),
+ cSIReportPerCSIProcessItem CSIReportPerCSIProcessItem,
+ iE-Extensions ProtocolExtensionContainer { {CSIReportPerCSIProcess-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct CSIReportPerCSIProcess_elm : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CSIReportPerCSIProcess_elm";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct cSIProcessConfigurationIndex_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 7>>;
+ static constexpr const char* name() {return "cSIProcessConfigurationIndex_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ cSIProcessConfigurationIndex_t& ref_cSIProcessConfigurationIndex() {return cSIProcessConfigurationIndex;}
+ cSIProcessConfigurationIndex_t const& ref_cSIProcessConfigurationIndex() const {return cSIProcessConfigurationIndex;}
+ struct cSIReportPerCSIProcessItem_t : CSIReportPerCSIProcessItem
+ {
+ static constexpr const char* name() {return "cSIReportPerCSIProcessItem_t";}
+ using parent_t = CSIReportPerCSIProcessItem;
+
+ };
+ cSIReportPerCSIProcessItem_t& ref_cSIReportPerCSIProcessItem() {return cSIReportPerCSIProcessItem;}
+ cSIReportPerCSIProcessItem_t const& ref_cSIReportPerCSIProcessItem() const {return cSIReportPerCSIProcessItem;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(cSIProcessConfigurationIndex);
+ v(cSIReportPerCSIProcessItem);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(cSIProcessConfigurationIndex);
+ v(cSIReportPerCSIProcessItem);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ cSIProcessConfigurationIndex.clear();
+ cSIReportPerCSIProcessItem.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ cSIProcessConfigurationIndex_t cSIProcessConfigurationIndex;
+ cSIReportPerCSIProcessItem_t cSIReportPerCSIProcessItem;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CSIReportPerCSIProcess : asn::sequenceof<CSIReportPerCSIProcess_elm>
+{
+ static constexpr const char* name() {return "CSIReportPerCSIProcess";}
+ using parent_t = asn::sequenceof<CSIReportPerCSIProcess_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCSIProcess >>;
+
+};
+/*
+CSIReportList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CSIReportList_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CSIReportList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
+ SEQUENCE {
+ uEID UEID,
+ cSIReportPerCSIProcess CSIReportPerCSIProcess,
+ iE-Extensions ProtocolExtensionContainer { {CSIReportList-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct CSIReportList_elm : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CSIReportList_elm";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct uEID_t : UEID
+ {
+ static constexpr const char* name() {return "uEID_t";}
+ using parent_t = UEID;
+
+ };
+ uEID_t& ref_uEID() {return uEID;}
+ uEID_t const& ref_uEID() const {return uEID;}
+ struct cSIReportPerCSIProcess_t : CSIReportPerCSIProcess
+ {
+ static constexpr const char* name() {return "cSIReportPerCSIProcess_t";}
+ using parent_t = CSIReportPerCSIProcess;
+
+ };
+ cSIReportPerCSIProcess_t& ref_cSIReportPerCSIProcess() {return cSIReportPerCSIProcess;}
+ cSIReportPerCSIProcess_t const& ref_cSIReportPerCSIProcess() const {return cSIReportPerCSIProcess;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportList_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CSIReportList_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uEID);
+ v(cSIReportPerCSIProcess);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uEID);
+ v(cSIReportPerCSIProcess);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uEID.clear();
+ cSIReportPerCSIProcess.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uEID_t uEID;
+ cSIReportPerCSIProcess_t cSIReportPerCSIProcess;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CSIReportList : asn::sequenceof<CSIReportList_elm>
+{
+ static constexpr const char* name() {return "CSIReportList";}
+ using parent_t = asn::sequenceof<CSIReportList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxUEReport >>;
+
+};
+/*
+CapacityValue ::= INTEGER (0..100)
+*/
+
+struct CapacityValue : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "CapacityValue";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+CauseRadioNetwork ::= ENUMERATED {
+ handover-desirable-for-radio-reasons,
+ time-critical-handover,
+ resource-optimisation-handover,
+ reduce-load-in-serving-cell,
+ partial-handover,
+ unknown-new-eNB-UE-X2AP-ID,
+ unknown-old-eNB-UE-X2AP-ID,
+ unknown-pair-of-UE-X2AP-ID,
+ ho-target-not-allowed,
+ tx2relocoverall-expiry,
+ trelocprep-expiry,
+ cell-not-available,
+ no-radio-resources-available-in-target-cell,
+ invalid-MME-GroupID,
+ unknown-MME-Code,
+ encryption-and-or-integrity-protection-algorithms-not-supported,
+ reportCharacteristicsEmpty,
+ noReportPeriodicity,
+ existingMeasurementID,
+ unknown-eNB-Measurement-ID,
+ measurement-temporarily-not-available,
+ unspecified,
+ ...,
+ load-balancing,
+ handover-optimisation,
+ value-out-of-allowed-range,
+ multiple-E-RAB-ID-instances,
+ switch-off-ongoing,
+ not-supported-QCI-value,
+ measurement-not-supported-for-the-object,
+ tDCoverall-expiry,
+ tDCprep-expiry,
+ action-desirable-for-radio-reasons,
+ reduce-load,
+ resource-optimisation,
+ time-critical-action,
+ target-not-allowed,
+ no-radio-resources-available,
+ invalid-QoS-combination,
+ encryption-algorithms-not-aupported,
+ procedure-cancelled,
+ rRM-purpose,
+ improve-user-bit-rate,
+ user-inactivity,
+ radio-connection-with-UE-lost,
+ failure-in-the-radio-interface-procedure,
+ bearer-option-not-supported,
+ mCG-Mobility,
+ sCG-Mobility,
+ count-reaches-max-value,
+ unknown-old-en-gNB-UE-X2AP-ID,
+ pDCP-Overload
+
+}
+*/
+
+struct CauseRadioNetwork : asn::enumerated<51, 29, true>
+{
+ static constexpr const char* name() {return "CauseRadioNetwork";}
+ using parent_t = asn::enumerated<51, 29, true>;
+ typedef enum {
+ handover_desirable_for_radio_reasons
+ ,time_critical_handover
+ ,resource_optimisation_handover
+ ,reduce_load_in_serving_cell
+ ,partial_handover
+ ,unknown_new_eNB_UE_X2AP_ID
+ ,unknown_old_eNB_UE_X2AP_ID
+ ,unknown_pair_of_UE_X2AP_ID
+ ,ho_target_not_allowed
+ ,tx2relocoverall_expiry
+ ,trelocprep_expiry
+ ,cell_not_available
+ ,no_radio_resources_available_in_target_cell
+ ,invalid_MME_GroupID
+ ,unknown_MME_Code
+ ,encryption_and_or_integrity_protection_algorithms_not_supported
+ ,reportCharacteristicsEmpty
+ ,noReportPeriodicity
+ ,existingMeasurementID
+ ,unknown_eNB_Measurement_ID
+ ,measurement_temporarily_not_available
+ ,unspecified
+ ,load_balancing
+ ,handover_optimisation
+ ,value_out_of_allowed_range
+ ,multiple_E_RAB_ID_instances
+ ,switch_off_ongoing
+ ,not_supported_QCI_value
+ ,measurement_not_supported_for_the_object
+ ,tDCoverall_expiry
+ ,tDCprep_expiry
+ ,action_desirable_for_radio_reasons
+ ,reduce_load
+ ,resource_optimisation
+ ,time_critical_action
+ ,target_not_allowed
+ ,no_radio_resources_available
+ ,invalid_QoS_combination
+ ,encryption_algorithms_not_aupported
+ ,procedure_cancelled
+ ,rRM_purpose
+ ,improve_user_bit_rate
+ ,user_inactivity
+ ,radio_connection_with_UE_lost
+ ,failure_in_the_radio_interface_procedure
+ ,bearer_option_not_supported
+ ,mCG_Mobility
+ ,sCG_Mobility
+ ,count_reaches_max_value
+ ,unknown_old_en_gNB_UE_X2AP_ID
+ ,pDCP_Overload
+ } index_t;
+
+};
+
+/*
+CauseTransport ::= ENUMERATED {
+ transport-resource-unavailable,
+ unspecified,
+ ...
+}
+*/
+
+struct CauseTransport : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "CauseTransport";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ transport_resource_unavailable
+ ,unspecified
+ } index_t;
+
+};
+
+/*
+CauseProtocol ::= ENUMERATED {
+ transfer-syntax-error,
+ abstract-syntax-error-reject,
+ abstract-syntax-error-ignore-and-notify,
+ message-not-compatible-with-receiver-state,
+ semantic-error,
+ unspecified,
+ abstract-syntax-error-falsely-constructed-message,
+ ...
+}
+*/
+
+struct CauseProtocol : asn::enumerated<7, 0, true>
+{
+ static constexpr const char* name() {return "CauseProtocol";}
+ using parent_t = asn::enumerated<7, 0, true>;
+ typedef enum {
+ transfer_syntax_error
+ ,abstract_syntax_error_reject
+ ,abstract_syntax_error_ignore_and_notify
+ ,message_not_compatible_with_receiver_state
+ ,semantic_error
+ ,unspecified
+ ,abstract_syntax_error_falsely_constructed_message
+ } index_t;
+
+};
+
+/*
+CauseMisc ::= ENUMERATED {
+ control-processing-overload,
+ hardware-failure,
+ om-intervention,
+ not-enough-user-plane-processing-resources,
+ unspecified,
+ ...
+}
+*/
+
+struct CauseMisc : asn::enumerated<5, 0, true>
+{
+ static constexpr const char* name() {return "CauseMisc";}
+ using parent_t = asn::enumerated<5, 0, true>;
+ typedef enum {
+ control_processing_overload
+ ,hardware_failure
+ ,om_intervention
+ ,not_enough_user_plane_processing_resources
+ ,unspecified
+ } index_t;
+
+};
+
+/*
+Cause ::= CHOICE {
+ radioNetwork CauseRadioNetwork,
+ transport CauseTransport,
+ protocol CauseProtocol,
+ misc CauseMisc,
+ ...
+}
+*/
+
+struct Cause : asn::choice<4, 0, true>
+{
+ static constexpr const char* name() {return "Cause";}
+ using parent_t = asn::choice<4, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~Cause() {clear();}
+ struct radioNetwork_t : CauseRadioNetwork
+ {
+ static constexpr const char* name() {return "radioNetwork_t";}
+ using parent_t = CauseRadioNetwork;
+
+ };
+ struct transport_t : CauseTransport
+ {
+ static constexpr const char* name() {return "transport_t";}
+ using parent_t = CauseTransport;
+
+ };
+ struct protocol_t : CauseProtocol
+ {
+ static constexpr const char* name() {return "protocol_t";}
+ using parent_t = CauseProtocol;
+
+ };
+ struct misc_t : CauseMisc
+ {
+ static constexpr const char* name() {return "misc_t";}
+ using parent_t = CauseMisc;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<radioNetwork_t>(); break;
+ case 2: var.destroy<transport_t>(); break;
+ case 3: var.destroy<protocol_t>(); break;
+ case 4: var.destroy<misc_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<radioNetwork_t>());
+ case 2: set_index(2); return v(var.build<transport_t>());
+ case 3: set_index(3); return v(var.build<protocol_t>());
+ case 4: set_index(4); return v(var.build<misc_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<radioNetwork_t>());
+ case 2: return v(var.as<transport_t>());
+ case 3: return v(var.as<protocol_t>());
+ case 4: return v(var.as<misc_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<radioNetwork_t>(1);
+ v.template operator()<transport_t>(2);
+ v.template operator()<protocol_t>(3);
+ v.template operator()<misc_t>(4);
+
+ }
+ radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
+ radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
+ transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
+ transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
+ protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
+ protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
+ misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
+ misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(radioNetwork_t)];
+ char dummy2[sizeof(transport_t)];
+ char dummy3[sizeof(protocol_t)];
+ char dummy4[sizeof(misc_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+Cell-Size ::= ENUMERATED {verysmall, small, medium, large, ... }
+*/
+
+struct Cell_Size : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "Cell-Size";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ verysmall
+ ,small
+ ,medium
+ ,large
+ } index_t;
+
+};
+
+/*
+CellCapacityClassValue ::= INTEGER (1..100, ...)
+*/
+
+struct CellCapacityClassValue : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 100>>;
+ static constexpr const char* name() {return "CellCapacityClassValue";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+CellDeploymentStatusIndicator ::= ENUMERATED {pre-change-notification, ...}
+*/
+
+struct CellDeploymentStatusIndicator : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "CellDeploymentStatusIndicator";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ pre_change_notification
+ } index_t;
+
+};
+
+/*
+ReplacingCellsList-Item ::= SEQUENCE {
+ eCGI ECGI,
+ ...
+}
+*/
+
+struct ReplacingCellsList_Item : asn::sequence<1, 0, true, 0>
+{
+ static constexpr const char* name() {return "ReplacingCellsList-Item";}
+ using parent_t = asn::sequence<1, 0, true, 0>;
+ struct eCGI_t : ECGI
+ {
+ static constexpr const char* name() {return "eCGI_t";}
+ using parent_t = ECGI;
+
+ };
+ eCGI_t& ref_eCGI() {return eCGI;}
+ eCGI_t const& ref_eCGI() const {return eCGI;}
+ template<typename V> void decode(V& v)
+ {
+ v(eCGI);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eCGI);
+
+ };
+ void clear()
+ {
+ eCGI.clear();
+
+ };
+ private:
+ eCGI_t eCGI;
+
+};
+/*
+ReplacingCellsList ::= SEQUENCE (SIZE(0.. maxCellineNB)) OF ReplacingCellsList-Item
+*/
+
+struct ReplacingCellsList_elm : ReplacingCellsList_Item
+{
+ static constexpr const char* name() {return "ReplacingCellsList_elm";}
+ using parent_t = ReplacingCellsList_Item;
+
+};
+struct ReplacingCellsList : asn::sequenceof<ReplacingCellsList_elm>
+{
+ static constexpr const char* name() {return "ReplacingCellsList";}
+ using parent_t = asn::sequenceof<ReplacingCellsList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxCellineNB >>;
+
+};
+/*
+CellReplacingInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CellReplacingInfo_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CellReplacingInfo ::= SEQUENCE {
+ replacingCellsList ReplacingCellsList,
+ iE-Extensions ProtocolExtensionContainer { {CellReplacingInfo-ExtIEs}} OPTIONAL,
+ ...
+}
+*/
+
+struct CellReplacingInfo : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "CellReplacingInfo";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct replacingCellsList_t : ReplacingCellsList
+ {
+ static constexpr const char* name() {return "replacingCellsList_t";}
+ using parent_t = ReplacingCellsList;
+
+ };
+ replacingCellsList_t& ref_replacingCellsList() {return replacingCellsList;}
+ replacingCellsList_t const& ref_replacingCellsList() const {return replacingCellsList;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(replacingCellsList);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(replacingCellsList);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ replacingCellsList.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ replacingCellsList_t replacingCellsList;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CellReportingIndicator ::= ENUMERATED {stop-request, ... }
+*/
+
+struct CellReportingIndicator : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "CellReportingIndicator";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ stop_request
+ } index_t;
+
+};
+
+/*
+CellType-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CellType_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CellType ::= SEQUENCE {
+ cell-Size Cell-Size,
+ iE-Extensions ProtocolExtensionContainer { {CellType-ExtIEs}} OPTIONAL,
+ ...
+}
+*/
+
+struct CellType : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "CellType";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct cell_Size_t : Cell_Size
+ {
+ static constexpr const char* name() {return "cell_Size_t";}
+ using parent_t = Cell_Size;
+
+ };
+ cell_Size_t& ref_cell_Size() {return cell_Size;}
+ cell_Size_t const& ref_cell_Size() const {return cell_Size;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CellType_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CellType_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(cell_Size);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(cell_Size);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ cell_Size.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ cell_Size_t cell_Size;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CoMPHypothesisSetItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CoMPHypothesisSetItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CoMPHypothesisSetItem ::= SEQUENCE {
+ coMPCellID ECGI,
+ coMPHypothesis BIT STRING (SIZE(6..4400, ...)),
+ iE-Extensions ProtocolExtensionContainer { {CoMPHypothesisSetItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CoMPHypothesisSetItem : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CoMPHypothesisSetItem";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct coMPCellID_t : ECGI
+ {
+ static constexpr const char* name() {return "coMPCellID_t";}
+ using parent_t = ECGI;
+
+ };
+ coMPCellID_t& ref_coMPCellID() {return coMPCellID;}
+ coMPCellID_t const& ref_coMPCellID() const {return coMPCellID;}
+ struct coMPHypothesis_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+ static constexpr const char* name() {return "coMPHypothesis_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ coMPHypothesis_t& ref_coMPHypothesis() {return coMPHypothesis;}
+ coMPHypothesis_t const& ref_coMPHypothesis() const {return coMPHypothesis;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(coMPCellID);
+ v(coMPHypothesis);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(coMPCellID);
+ v(coMPHypothesis);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ coMPCellID.clear();
+ coMPHypothesis.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ coMPCellID_t coMPCellID;
+ coMPHypothesis_t coMPHypothesis;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CoMPHypothesisSet ::= SEQUENCE (SIZE(1..maxnoofCoMPCells)) OF CoMPHypothesisSetItem
+*/
+
+struct CoMPHypothesisSet_elm : CoMPHypothesisSetItem
+{
+ static constexpr const char* name() {return "CoMPHypothesisSet_elm";}
+ using parent_t = CoMPHypothesisSetItem;
+
+};
+struct CoMPHypothesisSet : asn::sequenceof<CoMPHypothesisSet_elm>
+{
+ static constexpr const char* name() {return "CoMPHypothesisSet";}
+ using parent_t = asn::sequenceof<CoMPHypothesisSet_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofCoMPCells >>;
+
+};
+/*
+CoMPInformationItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CoMPInformationItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CoMPInformationItem ::= SEQUENCE (SIZE(1..maxnoofCoMPHypothesisSet)) OF
+ SEQUENCE {
+ coMPHypothesisSet CoMPHypothesisSet,
+ benefitMetric BenefitMetric,
+ iE-Extensions ProtocolExtensionContainer { {CoMPInformationItem-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct CoMPInformationItem_elm : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CoMPInformationItem_elm";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct coMPHypothesisSet_t : CoMPHypothesisSet
+ {
+ static constexpr const char* name() {return "coMPHypothesisSet_t";}
+ using parent_t = CoMPHypothesisSet;
+
+ };
+ coMPHypothesisSet_t& ref_coMPHypothesisSet() {return coMPHypothesisSet;}
+ coMPHypothesisSet_t const& ref_coMPHypothesisSet() const {return coMPHypothesisSet;}
+ struct benefitMetric_t : BenefitMetric
+ {
+ static constexpr const char* name() {return "benefitMetric_t";}
+ using parent_t = BenefitMetric;
+
+ };
+ benefitMetric_t& ref_benefitMetric() {return benefitMetric;}
+ benefitMetric_t const& ref_benefitMetric() const {return benefitMetric;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(coMPHypothesisSet);
+ v(benefitMetric);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(coMPHypothesisSet);
+ v(benefitMetric);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ coMPHypothesisSet.clear();
+ benefitMetric.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ coMPHypothesisSet_t coMPHypothesisSet;
+ benefitMetric_t benefitMetric;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CoMPInformationItem : asn::sequenceof<CoMPInformationItem_elm>
+{
+ static constexpr const char* name() {return "CoMPInformationItem";}
+ using parent_t = asn::sequenceof<CoMPInformationItem_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofCoMPHypothesisSet >>;
+
+};
+/*
+CoMPInformationStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CoMPInformationStartTime_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CoMPInformationStartTime ::= SEQUENCE (SIZE(0..1)) OF
+ SEQUENCE {
+ startSFN INTEGER (0..1023, ...),
+ startSubframeNumber INTEGER (0..9, ...),
+ iE-Extensions ProtocolExtensionContainer { {CoMPInformationStartTime-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct CoMPInformationStartTime_elm : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CoMPInformationStartTime_elm";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct startSFN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
+ static constexpr const char* name() {return "startSFN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ startSFN_t& ref_startSFN() {return startSFN;}
+ startSFN_t const& ref_startSFN() const {return startSFN;}
+ struct startSubframeNumber_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 9>>;
+ static constexpr const char* name() {return "startSubframeNumber_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
+ startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(startSFN);
+ v(startSubframeNumber);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(startSFN);
+ v(startSubframeNumber);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ startSFN.clear();
+ startSubframeNumber.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ startSFN_t startSFN;
+ startSubframeNumber_t startSubframeNumber;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CoMPInformationStartTime : asn::sequenceof<CoMPInformationStartTime_elm>
+{
+ static constexpr const char* name() {return "CoMPInformationStartTime";}
+ using parent_t = asn::sequenceof<CoMPInformationStartTime_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, 1>>;
+
+};
+/*
+CoMPInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CoMPInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CoMPInformation ::= SEQUENCE {
+ coMPInformationItem CoMPInformationItem,
+ coMPInformationStartTime CoMPInformationStartTime,
+ iE-Extensions ProtocolExtensionContainer { {CoMPInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CoMPInformation : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CoMPInformation";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct coMPInformationItem_t : CoMPInformationItem
+ {
+ static constexpr const char* name() {return "coMPInformationItem_t";}
+ using parent_t = CoMPInformationItem;
+
+ };
+ coMPInformationItem_t& ref_coMPInformationItem() {return coMPInformationItem;}
+ coMPInformationItem_t const& ref_coMPInformationItem() const {return coMPInformationItem;}
+ struct coMPInformationStartTime_t : CoMPInformationStartTime
+ {
+ static constexpr const char* name() {return "coMPInformationStartTime_t";}
+ using parent_t = CoMPInformationStartTime;
+
+ };
+ coMPInformationStartTime_t& ref_coMPInformationStartTime() {return coMPInformationStartTime;}
+ coMPInformationStartTime_t const& ref_coMPInformationStartTime() const {return coMPInformationStartTime;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CoMPInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(coMPInformationItem);
+ v(coMPInformationStartTime);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(coMPInformationItem);
+ v(coMPInformationStartTime);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ coMPInformationItem.clear();
+ coMPInformationStartTime.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ coMPInformationItem_t coMPInformationItem;
+ coMPInformationStartTime_t coMPInformationStartTime;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CompositeAvailableCapacity-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CompositeAvailableCapacity_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CompositeAvailableCapacity ::= SEQUENCE {
+ cellCapacityClassValue CellCapacityClassValue OPTIONAL,
+ capacityValue CapacityValue,
+ iE-Extensions ProtocolExtensionContainer { {CompositeAvailableCapacity-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CompositeAvailableCapacity : asn::sequence<3, 0, true, 2>
+{
+ static constexpr const char* name() {return "CompositeAvailableCapacity";}
+ using parent_t = asn::sequence<3, 0, true, 2>;
+ struct cellCapacityClassValue_t : CellCapacityClassValue
+ {
+ static constexpr const char* name() {return "cellCapacityClassValue_t";}
+ using parent_t = CellCapacityClassValue;
+ static constexpr bool optional = true;
+
+ };
+ cellCapacityClassValue_t& set_cellCapacityClassValue() { cellCapacityClassValue.setpresent(true); return cellCapacityClassValue;}
+ cellCapacityClassValue_t const* get_cellCapacityClassValue() const {return cellCapacityClassValue.is_valid() ? &cellCapacityClassValue : nullptr;}
+ struct capacityValue_t : CapacityValue
+ {
+ static constexpr const char* name() {return "capacityValue_t";}
+ using parent_t = CapacityValue;
+
+ };
+ capacityValue_t& ref_capacityValue() {return capacityValue;}
+ capacityValue_t const& ref_capacityValue() const {return capacityValue;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(cellCapacityClassValue);
+ v(capacityValue);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(cellCapacityClassValue);
+ v(capacityValue);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ cellCapacityClassValue.clear();
+ capacityValue.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ cellCapacityClassValue_t cellCapacityClassValue;
+ capacityValue_t capacityValue;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+CompositeAvailableCapacityGroup-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CompositeAvailableCapacityGroup_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CompositeAvailableCapacityGroup ::= SEQUENCE {
+ dL-CompositeAvailableCapacity CompositeAvailableCapacity,
+ uL-CompositeAvailableCapacity CompositeAvailableCapacity,
+ iE-Extensions ProtocolExtensionContainer { {CompositeAvailableCapacityGroup-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CompositeAvailableCapacityGroup : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "CompositeAvailableCapacityGroup";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct dL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
+ {
+ static constexpr const char* name() {return "dL_CompositeAvailableCapacity_t";}
+ using parent_t = CompositeAvailableCapacity;
+
+ };
+ dL_CompositeAvailableCapacity_t& ref_dL_CompositeAvailableCapacity() {return dL_CompositeAvailableCapacity;}
+ dL_CompositeAvailableCapacity_t const& ref_dL_CompositeAvailableCapacity() const {return dL_CompositeAvailableCapacity;}
+ struct uL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
+ {
+ static constexpr const char* name() {return "uL_CompositeAvailableCapacity_t";}
+ using parent_t = CompositeAvailableCapacity;
+
+ };
+ uL_CompositeAvailableCapacity_t& ref_uL_CompositeAvailableCapacity() {return uL_CompositeAvailableCapacity;}
+ uL_CompositeAvailableCapacity_t const& ref_uL_CompositeAvailableCapacity() const {return uL_CompositeAvailableCapacity;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dL_CompositeAvailableCapacity);
+ v(uL_CompositeAvailableCapacity);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dL_CompositeAvailableCapacity);
+ v(uL_CompositeAvailableCapacity);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dL_CompositeAvailableCapacity.clear();
+ uL_CompositeAvailableCapacity.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dL_CompositeAvailableCapacity_t dL_CompositeAvailableCapacity;
+ uL_CompositeAvailableCapacity_t uL_CompositeAvailableCapacity;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+Correlation-ID ::= OCTET STRING (SIZE (4))
+*/
+
+struct Correlation_ID : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<4>>;
+ static constexpr const char* name() {return "Correlation-ID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+CoverageModification-Item ::= SEQUENCE {
+ eCGI ECGI,
+ coverageState INTEGER (0..15, ...),
+ cellDeploymentStatusIndicator CellDeploymentStatusIndicator OPTIONAL,
+ cellReplacingInfo CellReplacingInfo OPTIONAL,
+-- Included in case the Cell Deployment Status Indicator IE is present
+ ...
+}
+*/
+
+struct CoverageModification_Item : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "CoverageModification-Item";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct eCGI_t : ECGI
+ {
+ static constexpr const char* name() {return "eCGI_t";}
+ using parent_t = ECGI;
+
+ };
+ eCGI_t& ref_eCGI() {return eCGI;}
+ eCGI_t const& ref_eCGI() const {return eCGI;}
+ struct coverageState_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "coverageState_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ coverageState_t& ref_coverageState() {return coverageState;}
+ coverageState_t const& ref_coverageState() const {return coverageState;}
+ struct cellDeploymentStatusIndicator_t : CellDeploymentStatusIndicator
+ {
+ static constexpr const char* name() {return "cellDeploymentStatusIndicator_t";}
+ using parent_t = CellDeploymentStatusIndicator;
+ static constexpr bool optional = true;
+
+ };
+ cellDeploymentStatusIndicator_t& set_cellDeploymentStatusIndicator() { cellDeploymentStatusIndicator.setpresent(true); return cellDeploymentStatusIndicator;}
+ cellDeploymentStatusIndicator_t const* get_cellDeploymentStatusIndicator() const {return cellDeploymentStatusIndicator.is_valid() ? &cellDeploymentStatusIndicator : nullptr;}
+ struct cellReplacingInfo_t : CellReplacingInfo
+ {
+ static constexpr const char* name() {return "cellReplacingInfo_t";}
+ using parent_t = CellReplacingInfo;
+ static constexpr bool optional = true;
+
+ };
+ cellReplacingInfo_t& set_cellReplacingInfo() { cellReplacingInfo.setpresent(true); return cellReplacingInfo;}
+ cellReplacingInfo_t const* get_cellReplacingInfo() const {return cellReplacingInfo.is_valid() ? &cellReplacingInfo : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eCGI);
+ v(coverageState);
+ v(cellDeploymentStatusIndicator);
+ v(cellReplacingInfo);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eCGI);
+ v(coverageState);
+ v(cellDeploymentStatusIndicator);
+ v(cellReplacingInfo);
+
+ };
+ void clear()
+ {
+ eCGI.clear();
+ coverageState.clear();
+ cellDeploymentStatusIndicator.clear();
+ cellReplacingInfo.clear();
+
+ };
+ private:
+ eCGI_t eCGI;
+ coverageState_t coverageState;
+ cellDeploymentStatusIndicator_t cellDeploymentStatusIndicator;
+ cellReplacingInfo_t cellReplacingInfo;
+
+};
+/*
+CoverageModificationList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF CoverageModification-Item
+*/
+
+struct CoverageModificationList_elm : CoverageModification_Item
+{
+ static constexpr const char* name() {return "CoverageModificationList_elm";}
+ using parent_t = CoverageModification_Item;
+
+};
+struct CoverageModificationList : asn::sequenceof<CoverageModificationList_elm>
+{
+ static constexpr const char* name() {return "CoverageModificationList";}
+ using parent_t = asn::sequenceof<CoverageModificationList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
+
+};
+/*
+TypeOfError ::= ENUMERATED {
+ not-understood,
+ missing,
+ ...
+}
+*/
+
+struct TypeOfError : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "TypeOfError";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ not_understood
+ ,missing
+ } index_t;
+
+};
+
+/*
+CriticalityDiagnostics-IE-List-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CriticalityDiagnostics_IE_List_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE (1..maxNrOfErrors)) OF
+ SEQUENCE {
+ iECriticality Criticality,
+ iE-ID ProtocolIE-ID,
+ typeOfError TypeOfError,
+ iE-Extensions ProtocolExtensionContainer { {CriticalityDiagnostics-IE-List-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CriticalityDiagnostics_IE_List_elm : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "CriticalityDiagnostics_IE_List_elm";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct iECriticality_t : Criticality
+ {
+ static constexpr const char* name() {return "iECriticality_t";}
+ using parent_t = Criticality;
+
+ };
+ iECriticality_t& ref_iECriticality() {return iECriticality;}
+ iECriticality_t const& ref_iECriticality() const {return iECriticality;}
+ struct iE_ID_t : ProtocolIE_ID
+ {
+ static constexpr const char* name() {return "iE_ID_t";}
+ using parent_t = ProtocolIE_ID;
+
+ };
+ iE_ID_t& ref_iE_ID() {return iE_ID;}
+ iE_ID_t const& ref_iE_ID() const {return iE_ID;}
+ struct typeOfError_t : TypeOfError
+ {
+ static constexpr const char* name() {return "typeOfError_t";}
+ using parent_t = TypeOfError;
+
+ };
+ typeOfError_t& ref_typeOfError() {return typeOfError;}
+ typeOfError_t const& ref_typeOfError() const {return typeOfError;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(iECriticality);
+ v(iE_ID);
+ v(typeOfError);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(iECriticality);
+ v(iE_ID);
+ v(typeOfError);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ iECriticality.clear();
+ iE_ID.clear();
+ typeOfError.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ iECriticality_t iECriticality;
+ iE_ID_t iE_ID;
+ typeOfError_t typeOfError;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct CriticalityDiagnostics_IE_List : asn::sequenceof<CriticalityDiagnostics_IE_List_elm>
+{
+ static constexpr const char* name() {return "CriticalityDiagnostics-IE-List";}
+ using parent_t = asn::sequenceof<CriticalityDiagnostics_IE_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxNrOfErrors >>;
+
+};
+/*
+CriticalityDiagnostics-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct CriticalityDiagnostics_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+CriticalityDiagnostics ::= SEQUENCE {
+ procedureCode ProcedureCode OPTIONAL,
+ triggeringMessage TriggeringMessage OPTIONAL,
+ procedureCriticality Criticality OPTIONAL,
+ iEsCriticalityDiagnostics CriticalityDiagnostics-IE-List OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {CriticalityDiagnostics-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct CriticalityDiagnostics : asn::sequence<5, 0, true, 5>
+{
+ static constexpr const char* name() {return "CriticalityDiagnostics";}
+ using parent_t = asn::sequence<5, 0, true, 5>;
+ struct procedureCode_t : ProcedureCode
+ {
+ static constexpr const char* name() {return "procedureCode_t";}
+ using parent_t = ProcedureCode;
+ static constexpr bool optional = true;
+
+ };
+ procedureCode_t& set_procedureCode() { procedureCode.setpresent(true); return procedureCode;}
+ procedureCode_t const* get_procedureCode() const {return procedureCode.is_valid() ? &procedureCode : nullptr;}
+ struct triggeringMessage_t : TriggeringMessage
+ {
+ static constexpr const char* name() {return "triggeringMessage_t";}
+ using parent_t = TriggeringMessage;
+ static constexpr bool optional = true;
+
+ };
+ triggeringMessage_t& set_triggeringMessage() { triggeringMessage.setpresent(true); return triggeringMessage;}
+ triggeringMessage_t const* get_triggeringMessage() const {return triggeringMessage.is_valid() ? &triggeringMessage : nullptr;}
+ struct procedureCriticality_t : Criticality
+ {
+ static constexpr const char* name() {return "procedureCriticality_t";}
+ using parent_t = Criticality;
+ static constexpr bool optional = true;
+
+ };
+ procedureCriticality_t& set_procedureCriticality() { procedureCriticality.setpresent(true); return procedureCriticality;}
+ procedureCriticality_t const* get_procedureCriticality() const {return procedureCriticality.is_valid() ? &procedureCriticality : nullptr;}
+ struct iEsCriticalityDiagnostics_t : CriticalityDiagnostics_IE_List
+ {
+ static constexpr const char* name() {return "iEsCriticalityDiagnostics_t";}
+ using parent_t = CriticalityDiagnostics_IE_List;
+ static constexpr bool optional = true;
+
+ };
+ iEsCriticalityDiagnostics_t& set_iEsCriticalityDiagnostics() { iEsCriticalityDiagnostics.setpresent(true); return iEsCriticalityDiagnostics;}
+ iEsCriticalityDiagnostics_t const* get_iEsCriticalityDiagnostics() const {return iEsCriticalityDiagnostics.is_valid() ? &iEsCriticalityDiagnostics : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(procedureCode);
+ v(triggeringMessage);
+ v(procedureCriticality);
+ v(iEsCriticalityDiagnostics);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(procedureCode);
+ v(triggeringMessage);
+ v(procedureCriticality);
+ v(iEsCriticalityDiagnostics);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ procedureCode.clear();
+ triggeringMessage.clear();
+ procedureCriticality.clear();
+ iEsCriticalityDiagnostics.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ procedureCode_t procedureCode;
+ triggeringMessage_t triggeringMessage;
+ procedureCriticality_t procedureCriticality;
+ iEsCriticalityDiagnostics_t iEsCriticalityDiagnostics;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+DL-Forwarding ::= ENUMERATED {
+ dL-forwardingProposed,
+ ...
+}
+*/
+
+struct DL_Forwarding : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "DL-Forwarding";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ dL_forwardingProposed
+ } index_t;
+
+};
+
+/*
+DL-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_GBR_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "DL-GBR-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-Total-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_Total_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "DL-Total-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-non-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct DL_non_GBR_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "DL-non-GBR-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+DL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
+*/
+
+struct DL_scheduling_PDCCH_CCE_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "DL-scheduling-PDCCH-CCE-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+DataTrafficResources ::= BIT STRING (SIZE(6..17600))
+*/
+
+struct DataTrafficResources : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<6, 17600>>;
+ static constexpr const char* name() {return "DataTrafficResources";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+DLResourceBitmapULandDLSharing ::= DataTrafficResources
+*/
+
+struct DLResourceBitmapULandDLSharing : DataTrafficResources
+{
+ static constexpr const char* name() {return "DLResourceBitmapULandDLSharing";}
+ using parent_t = DataTrafficResources;
+
+};
+/*
+DLResourcesULandDLSharing ::= CHOICE {
+unchanged NULL,
+ changed DLResourceBitmapULandDLSharing,
+ ...
+}
+*/
+
+struct DLResourcesULandDLSharing : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "DLResourcesULandDLSharing";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~DLResourcesULandDLSharing() {clear();}
+ struct unchanged_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "unchanged_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ struct changed_t : DLResourceBitmapULandDLSharing
+ {
+ static constexpr const char* name() {return "changed_t";}
+ using parent_t = DLResourceBitmapULandDLSharing;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<unchanged_t>(); break;
+ case 2: var.destroy<changed_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<unchanged_t>());
+ case 2: set_index(2); return v(var.build<changed_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<unchanged_t>());
+ case 2: return v(var.as<changed_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<unchanged_t>(1);
+ v.template operator()<changed_t>(2);
+
+ }
+ unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
+ unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
+ changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
+ changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(unchanged_t)];
+ char dummy2[sizeof(changed_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+DRB-ID ::= INTEGER (1..32)
+*/
+
+struct DRB_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 32>>;
+ static constexpr const char* name() {return "DRB-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+ULOnlySharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ULOnlySharing_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ULOnlySharing ::= SEQUENCE{
+ uLResourceBitmapULOnlySharing DataTrafficResources,
+ iE-Extensions ProtocolExtensionContainer { {ULOnlySharing-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ULOnlySharing : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "ULOnlySharing";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct uLResourceBitmapULOnlySharing_t : DataTrafficResources
+ {
+ static constexpr const char* name() {return "uLResourceBitmapULOnlySharing_t";}
+ using parent_t = DataTrafficResources;
+
+ };
+ uLResourceBitmapULOnlySharing_t& ref_uLResourceBitmapULOnlySharing() {return uLResourceBitmapULOnlySharing;}
+ uLResourceBitmapULOnlySharing_t const& ref_uLResourceBitmapULOnlySharing() const {return uLResourceBitmapULOnlySharing;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ULOnlySharing_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ULOnlySharing_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uLResourceBitmapULOnlySharing);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uLResourceBitmapULOnlySharing);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uLResourceBitmapULOnlySharing.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uLResourceBitmapULOnlySharing_t uLResourceBitmapULOnlySharing;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ULResourceBitmapULandDLSharing ::= DataTrafficResources
+*/
+
+struct ULResourceBitmapULandDLSharing : DataTrafficResources
+{
+ static constexpr const char* name() {return "ULResourceBitmapULandDLSharing";}
+ using parent_t = DataTrafficResources;
+
+};
+/*
+ULResourcesULandDLSharing ::= CHOICE {
+ unchanged NULL,
+ changed ULResourceBitmapULandDLSharing,
+ ...
+}
+*/
+
+struct ULResourcesULandDLSharing : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "ULResourcesULandDLSharing";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~ULResourcesULandDLSharing() {clear();}
+ struct unchanged_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "unchanged_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ struct changed_t : ULResourceBitmapULandDLSharing
+ {
+ static constexpr const char* name() {return "changed_t";}
+ using parent_t = ULResourceBitmapULandDLSharing;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<unchanged_t>(); break;
+ case 2: var.destroy<changed_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<unchanged_t>());
+ case 2: set_index(2); return v(var.build<changed_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<unchanged_t>());
+ case 2: return v(var.as<changed_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<unchanged_t>(1);
+ v.template operator()<changed_t>(2);
+
+ }
+ unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
+ unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
+ changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
+ changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(unchanged_t)];
+ char dummy2[sizeof(changed_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+ULandDLSharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ULandDLSharing_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ULandDLSharing ::= SEQUENCE{
+ uLResourcesULandDLSharing ULResourcesULandDLSharing,
+ dLResourcesULandDLSharing DLResourcesULandDLSharing,
+ iE-Extensions ProtocolExtensionContainer { {ULandDLSharing-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ULandDLSharing : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ULandDLSharing";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct uLResourcesULandDLSharing_t : ULResourcesULandDLSharing
+ {
+ static constexpr const char* name() {return "uLResourcesULandDLSharing_t";}
+ using parent_t = ULResourcesULandDLSharing;
+
+ };
+ uLResourcesULandDLSharing_t& ref_uLResourcesULandDLSharing() {return uLResourcesULandDLSharing;}
+ uLResourcesULandDLSharing_t const& ref_uLResourcesULandDLSharing() const {return uLResourcesULandDLSharing;}
+ struct dLResourcesULandDLSharing_t : DLResourcesULandDLSharing
+ {
+ static constexpr const char* name() {return "dLResourcesULandDLSharing_t";}
+ using parent_t = DLResourcesULandDLSharing;
+
+ };
+ dLResourcesULandDLSharing_t& ref_dLResourcesULandDLSharing() {return dLResourcesULandDLSharing;}
+ dLResourcesULandDLSharing_t const& ref_dLResourcesULandDLSharing() const {return dLResourcesULandDLSharing;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ULandDLSharing_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ULandDLSharing_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uLResourcesULandDLSharing);
+ v(dLResourcesULandDLSharing);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uLResourcesULandDLSharing);
+ v(dLResourcesULandDLSharing);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uLResourcesULandDLSharing.clear();
+ dLResourcesULandDLSharing.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uLResourcesULandDLSharing_t uLResourcesULandDLSharing;
+ dLResourcesULandDLSharing_t dLResourcesULandDLSharing;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SharedResourceType ::= CHOICE{
+ uLOnlySharing ULOnlySharing,
+ uLandDLSharing ULandDLSharing,
+ ...
+}
+*/
+
+struct SharedResourceType : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "SharedResourceType";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~SharedResourceType() {clear();}
+ struct uLOnlySharing_t : ULOnlySharing
+ {
+ static constexpr const char* name() {return "uLOnlySharing_t";}
+ using parent_t = ULOnlySharing;
+
+ };
+ struct uLandDLSharing_t : ULandDLSharing
+ {
+ static constexpr const char* name() {return "uLandDLSharing_t";}
+ using parent_t = ULandDLSharing;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<uLOnlySharing_t>(); break;
+ case 2: var.destroy<uLandDLSharing_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<uLOnlySharing_t>());
+ case 2: set_index(2); return v(var.build<uLandDLSharing_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<uLOnlySharing_t>());
+ case 2: return v(var.as<uLandDLSharing_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<uLOnlySharing_t>(1);
+ v.template operator()<uLandDLSharing_t>(2);
+
+ }
+ uLOnlySharing_t& select_uLOnlySharing() { if(get_index() != 1) { clear(); set_index(1); return var.build<uLOnlySharing_t>();} return var.as<uLOnlySharing_t>();}
+ uLOnlySharing_t const* get_uLOnlySharing() const { if(get_index() == 1) { return &var.as<uLOnlySharing_t>();} return nullptr; }
+ uLandDLSharing_t& select_uLandDLSharing() { if(get_index() != 2) { clear(); set_index(2); return var.build<uLandDLSharing_t>();} return var.as<uLandDLSharing_t>();}
+ uLandDLSharing_t const* get_uLandDLSharing() const { if(get_index() == 2) { return &var.as<uLandDLSharing_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(uLOnlySharing_t)];
+ char dummy2[sizeof(uLandDLSharing_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+SubframeType ::= ENUMERATED{mbsfn,nonmbsfn,...}
+*/
+
+struct SubframeType : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "SubframeType";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ mbsfn
+ ,nonmbsfn
+ } index_t;
+
+};
+
+/*
+ReservedSubframePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ReservedSubframePattern_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ReservedSubframePattern ::= SEQUENCE{
+ subframeType SubframeType,
+ reservedSubframePattern BIT STRING (SIZE(10..160)),
+ mBSFNControlRegionLength INTEGER (0..3),
+ iE-Extensions ProtocolExtensionContainer { {ReservedSubframePattern-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ReservedSubframePattern : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "ReservedSubframePattern";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct subframeType_t : SubframeType
+ {
+ static constexpr const char* name() {return "subframeType_t";}
+ using parent_t = SubframeType;
+
+ };
+ subframeType_t& ref_subframeType() {return subframeType;}
+ subframeType_t const& ref_subframeType() const {return subframeType;}
+ struct reservedSubframePattern_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<10, 160>>;
+ static constexpr const char* name() {return "reservedSubframePattern_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ reservedSubframePattern_t& ref_reservedSubframePattern() {return reservedSubframePattern;}
+ reservedSubframePattern_t const& ref_reservedSubframePattern() const {return reservedSubframePattern;}
+ struct mBSFNControlRegionLength_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+ static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ mBSFNControlRegionLength_t& ref_mBSFNControlRegionLength() {return mBSFNControlRegionLength;}
+ mBSFNControlRegionLength_t const& ref_mBSFNControlRegionLength() const {return mBSFNControlRegionLength;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(subframeType);
+ v(reservedSubframePattern);
+ v(mBSFNControlRegionLength);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(subframeType);
+ v(reservedSubframePattern);
+ v(mBSFNControlRegionLength);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ subframeType.clear();
+ reservedSubframePattern.clear();
+ mBSFNControlRegionLength.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ subframeType_t subframeType;
+ reservedSubframePattern_t reservedSubframePattern;
+ mBSFNControlRegionLength_t mBSFNControlRegionLength;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+DataTrafficResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct DataTrafficResourceIndication_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+DataTrafficResourceIndication ::= SEQUENCE {
+ activationSFN INTEGER (0..1023),
+ sharedResourceType SharedResourceType,
+ reservedSubframePattern ReservedSubframePattern OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {DataTrafficResourceIndication-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct DataTrafficResourceIndication : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "DataTrafficResourceIndication";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct activationSFN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
+ static constexpr const char* name() {return "activationSFN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ activationSFN_t& ref_activationSFN() {return activationSFN;}
+ activationSFN_t const& ref_activationSFN() const {return activationSFN;}
+ struct sharedResourceType_t : SharedResourceType
+ {
+ static constexpr const char* name() {return "sharedResourceType_t";}
+ using parent_t = SharedResourceType;
+
+ };
+ sharedResourceType_t& ref_sharedResourceType() {return sharedResourceType;}
+ sharedResourceType_t const& ref_sharedResourceType() const {return sharedResourceType;}
+ struct reservedSubframePattern_t : ReservedSubframePattern
+ {
+ static constexpr const char* name() {return "reservedSubframePattern_t";}
+ using parent_t = ReservedSubframePattern;
+ static constexpr bool optional = true;
+
+ };
+ reservedSubframePattern_t& set_reservedSubframePattern() { reservedSubframePattern.setpresent(true); return reservedSubframePattern;}
+ reservedSubframePattern_t const* get_reservedSubframePattern() const {return reservedSubframePattern.is_valid() ? &reservedSubframePattern : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(activationSFN);
+ v(sharedResourceType);
+ v(reservedSubframePattern);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(activationSFN);
+ v(sharedResourceType);
+ v(reservedSubframePattern);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ activationSFN.clear();
+ sharedResourceType.clear();
+ reservedSubframePattern.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ activationSFN_t activationSFN;
+ sharedResourceType_t sharedResourceType;
+ reservedSubframePattern_t reservedSubframePattern;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+DeactivationIndication::= ENUMERATED {
+ deactivated,
+ ...
+}
+*/
+
+struct DeactivationIndication : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "DeactivationIndication";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ deactivated
+ } index_t;
+
+};
+
+/*
+DeliveryStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct DeliveryStatus_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+DeliveryStatus ::= SEQUENCE {
+ highestSuccessDeliveredPDCPSN INTEGER (0..4095),
+ iE-Extensions ProtocolExtensionContainer { {DeliveryStatus-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct DeliveryStatus : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "DeliveryStatus";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct highestSuccessDeliveredPDCPSN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "highestSuccessDeliveredPDCPSN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ highestSuccessDeliveredPDCPSN_t& ref_highestSuccessDeliveredPDCPSN() {return highestSuccessDeliveredPDCPSN;}
+ highestSuccessDeliveredPDCPSN_t const& ref_highestSuccessDeliveredPDCPSN() const {return highestSuccessDeliveredPDCPSN;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<DeliveryStatus_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<DeliveryStatus_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(highestSuccessDeliveredPDCPSN);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(highestSuccessDeliveredPDCPSN);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ highestSuccessDeliveredPDCPSN.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ highestSuccessDeliveredPDCPSN_t highestSuccessDeliveredPDCPSN;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+DuplicationActivation::= ENUMERATED {active, inactive, ...}
+*/
+
+struct DuplicationActivation : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "DuplicationActivation";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ active
+ ,inactive
+ } index_t;
+
+};
+
+/*
+PA-Values ::= ENUMERATED {
+ dB-6,
+ dB-4dot77,
+ dB-3,
+ dB-1dot77,
+ dB0,
+ dB1,
+ dB2,
+ dB3,
+ ...
+}
+*/
+
+struct PA_Values : asn::enumerated<8, 0, true>
+{
+ static constexpr const char* name() {return "PA-Values";}
+ using parent_t = asn::enumerated<8, 0, true>;
+ typedef enum {
+ dB_6
+ ,dB_4dot77
+ ,dB_3
+ ,dB_1dot77
+ ,dB0
+ ,dB1
+ ,dB2
+ ,dB3
+ } index_t;
+
+};
+
+/*
+DynamicNAICSInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct DynamicNAICSInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+DynamicNAICSInformation ::= SEQUENCE {
+ transmissionModes BIT STRING (SIZE(8)) OPTIONAL,
+ pB-information INTEGER(0..3) OPTIONAL,
+ pA-list SEQUENCE (SIZE(0..maxnoofPA)) OF PA-Values,
+ iE-Extensions ProtocolExtensionContainer { {DynamicNAICSInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct DynamicNAICSInformation : asn::sequence<4, 0, true, 3>
+{
+ static constexpr const char* name() {return "DynamicNAICSInformation";}
+ using parent_t = asn::sequence<4, 0, true, 3>;
+ struct transmissionModes_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<8>>;
+ static constexpr const char* name() {return "transmissionModes_t";}
+ using parent_t = asn::bstring<>;
+ static constexpr bool optional = true;
+
+ };
+
+ transmissionModes_t& set_transmissionModes() { transmissionModes.setpresent(true); return transmissionModes;}
+ transmissionModes_t const* get_transmissionModes() const {return transmissionModes.is_valid() ? &transmissionModes : nullptr;}
+ struct pB_information_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+ static constexpr const char* name() {return "pB_information_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ pB_information_t& set_pB_information() { pB_information.setpresent(true); return pB_information;}
+ pB_information_t const* get_pB_information() const {return pB_information.is_valid() ? &pB_information : nullptr;}
+ struct pA_list_t_elm : PA_Values
+ {
+ static constexpr const char* name() {return "pA_list_t_elm";}
+ using parent_t = PA_Values;
+
+ };
+ struct pA_list_t : asn::sequenceof<pA_list_t_elm>
+ {
+ static constexpr const char* name() {return "pA_list_t";}
+ using parent_t = asn::sequenceof<pA_list_t_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxnoofPA >>;
+
+ };
+ pA_list_t& ref_pA_list() {return pA_list;}
+ pA_list_t const& ref_pA_list() const {return pA_list;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(transmissionModes);
+ v(pB_information);
+ v(pA_list);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(transmissionModes);
+ v(pB_information);
+ v(pA_list);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ transmissionModes.clear();
+ pB_information.clear();
+ pA_list.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ transmissionModes_t transmissionModes;
+ pB_information_t pB_information;
+ pA_list_t pA_list;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+DynamicDLTransmissionInformation ::= CHOICE {
+ naics-active DynamicNAICSInformation,
+ naics-inactive NULL,
+ ...
+}
+*/
+
+struct DynamicDLTransmissionInformation : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "DynamicDLTransmissionInformation";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~DynamicDLTransmissionInformation() {clear();}
+ struct naics_active_t : DynamicNAICSInformation
+ {
+ static constexpr const char* name() {return "naics_active_t";}
+ using parent_t = DynamicNAICSInformation;
+
+ };
+ struct naics_inactive_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "naics_inactive_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<naics_active_t>(); break;
+ case 2: var.destroy<naics_inactive_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<naics_active_t>());
+ case 2: set_index(2); return v(var.build<naics_inactive_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<naics_active_t>());
+ case 2: return v(var.as<naics_inactive_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<naics_active_t>(1);
+ v.template operator()<naics_inactive_t>(2);
+
+ }
+ naics_active_t& select_naics_active() { if(get_index() != 1) { clear(); set_index(1); return var.build<naics_active_t>();} return var.as<naics_active_t>();}
+ naics_active_t const* get_naics_active() const { if(get_index() == 1) { return &var.as<naics_active_t>();} return nullptr; }
+ naics_inactive_t& select_naics_inactive() { if(get_index() != 2) { clear(); set_index(2); return var.build<naics_inactive_t>();} return var.as<naics_inactive_t>();}
+ naics_inactive_t const* get_naics_inactive() const { if(get_index() == 2) { return &var.as<naics_inactive_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(naics_active_t)];
+ char dummy2[sizeof(naics_inactive_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+E-RAB-ID ::= INTEGER (0..15, ...)
+*/
+
+struct E_RAB_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<0, 15>>;
+ static constexpr const char* name() {return "E-RAB-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+E-RAB-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct E_RAB_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+E-RAB-Item ::= SEQUENCE {
+ e-RAB-ID E-RAB-ID,
+ cause Cause,
+ iE-Extensions ProtocolExtensionContainer { {E-RAB-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct E_RAB_Item : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "E-RAB-Item";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct e_RAB_ID_t : E_RAB_ID
+ {
+ static constexpr const char* name() {return "e_RAB_ID_t";}
+ using parent_t = E_RAB_ID;
+
+ };
+ e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+ e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+ struct cause_t : Cause
+ {
+ static constexpr const char* name() {return "cause_t";}
+ using parent_t = Cause;
+
+ };
+ cause_t& ref_cause() {return cause;}
+ cause_t const& ref_cause() const {return cause;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<E_RAB_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(e_RAB_ID);
+ v(cause);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(e_RAB_ID);
+ v(cause);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ e_RAB_ID.clear();
+ cause.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ e_RAB_ID_t e_RAB_ID;
+ cause_t cause;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+E-RAB-ItemIEs X2AP-PROTOCOL-IES ::= {
+ { ID id-E-RAB-Item CRITICALITY ignore TYPE E-RAB-Item PRESENCE mandatory },
+ ...
+}
+*/
+
+struct E_RAB_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_E_RAB_Item() { set(id_E_RAB_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_E_RAB_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_E_RAB_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_E_RAB_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;}
+ E_RAB_Item& select_id_E_RAB_Item() { return set<E_RAB_Item>(1); }
+ E_RAB_Item const* get_id_E_RAB_Item() const { return get<E_RAB_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<E_RAB_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<E_RAB_Item>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_E_RAB_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<E_RAB_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(E_RAB_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_E_RAB_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};
+
+ };
+
+};
+/*
+QCI ::= INTEGER (0..255)
+*/
+
+struct QCI : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 255>>;
+ static constexpr const char* name() {return "QCI";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+ExtendedBitRate ::= INTEGER (10000000001..4000000000000,...)
+*/
+
+struct ExtendedBitRate : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<10000000001, 4000000000000>>;
+ static constexpr const char* name() {return "ExtendedBitRate";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+GBR-QosInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extension for maximum bitrate > 10Gbps --
+ { ID id-extended-e-RAB-MaximumBitrateDL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
+ { ID id-extended-e-RAB-MaximumBitrateUL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
+ { ID id-extended-e-RAB-GuaranteedBitrateDL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
+ { ID id-extended-e-RAB-GuaranteedBitrateUL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional},
+ ...
+}
+*/
+
+struct GBR_QosInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 5; }
+ void clear() {type = 0;}
+ void select_id_extended_e_RAB_MaximumBitrateDL() { set(id_extended_e_RAB_MaximumBitrateDL); type=1;}
+ void select_id_extended_e_RAB_MaximumBitrateUL() { set(id_extended_e_RAB_MaximumBitrateUL); type=2;}
+ void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(id_extended_e_RAB_GuaranteedBitrateDL); type=3;}
+ void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(id_extended_e_RAB_GuaranteedBitrateUL); type=4;}
+ X2AP_PROTOCOL_EXTENSION::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_extended_e_RAB_MaximumBitrateDL)) { type = 1; return true; }
+ else if(equal(id_extended_e_RAB_MaximumBitrateUL)) { type = 2; return true; }
+ else if(equal(id_extended_e_RAB_GuaranteedBitrateDL)) { type = 3; return true; }
+ else if(equal(id_extended_e_RAB_GuaranteedBitrateUL)) { 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_extended_e_RAB_MaximumBitrateDL);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateUL);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateDL);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateUL);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 5; }
+ void clear() {type = 0;}
+ void select_id_extended_e_RAB_MaximumBitrateDL() { set(ignore); type=1;}
+ void select_id_extended_e_RAB_MaximumBitrateUL() { set(ignore); type=2;}
+ void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(ignore); type=3;}
+ void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(ignore); type=4;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { type = 2; return true; }
+ else if(equal(ignore)) { 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(ignore);} 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateDL() { return set<ExtendedBitRate>(1); }
+ ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateDL() const { return get<ExtendedBitRate>(1); }
+ ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateUL() { return set<ExtendedBitRate>(2); }
+ ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateUL() const { return get<ExtendedBitRate>(2); }
+ ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateDL() { return set<ExtendedBitRate>(3); }
+ ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateDL() const { return get<ExtendedBitRate>(3); }
+ ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateUL() { return set<ExtendedBitRate>(4); }
+ ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateUL() const { return get<ExtendedBitRate>(4); }
+ bool is_unknown() const { return type == 5; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<ExtendedBitRate>(); break;
+ case 2: var.destroy<ExtendedBitRate>(); break;
+ case 3: var.destroy<ExtendedBitRate>(); break;
+ case 4: var.destroy<ExtendedBitRate>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<ExtendedBitRate>(1);
+ v.template operator()<ExtendedBitRate>(2);
+ v.template operator()<ExtendedBitRate>(3);
+ v.template operator()<ExtendedBitRate>(4);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_extended_e_RAB_MaximumBitrateDL()); return true;
+ case 2: v(select_id_extended_e_RAB_MaximumBitrateUL()); return true;
+ case 3: v(select_id_extended_e_RAB_GuaranteedBitrateDL()); return true;
+ case 4: v(select_id_extended_e_RAB_GuaranteedBitrateUL()); 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<ExtendedBitRate>()); return true;
+ case 2: v(var.as<ExtendedBitRate>()); return true;
+ case 3: v(var.as<ExtendedBitRate>()); return true;
+ case 4: v(var.as<ExtendedBitRate>()); 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(ExtendedBitRate)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 5; }
+ void clear() {type = 0;}
+ void select_id_extended_e_RAB_MaximumBitrateDL() { set(optional); type=1;}
+ void select_id_extended_e_RAB_MaximumBitrateUL() { set(optional); type=2;}
+ void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(optional); type=3;}
+ void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(optional); type=4;}
+ X2AP_PROTOCOL_EXTENSION::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 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(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; 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};
+
+ };
+
+};
+/*
+GBR-QosInformation ::= SEQUENCE {
+ e-RAB-MaximumBitrateDL BitRate,
+ e-RAB-MaximumBitrateUL BitRate,
+ e-RAB-GuaranteedBitrateDL BitRate,
+ e-RAB-GuaranteedBitrateUL BitRate,
+ iE-Extensions ProtocolExtensionContainer { {GBR-QosInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GBR_QosInformation : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "GBR-QosInformation";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct e_RAB_MaximumBitrateDL_t : BitRate
+ {
+ static constexpr const char* name() {return "e_RAB_MaximumBitrateDL_t";}
+ using parent_t = BitRate;
+
+ };
+ e_RAB_MaximumBitrateDL_t& ref_e_RAB_MaximumBitrateDL() {return e_RAB_MaximumBitrateDL;}
+ e_RAB_MaximumBitrateDL_t const& ref_e_RAB_MaximumBitrateDL() const {return e_RAB_MaximumBitrateDL;}
+ struct e_RAB_MaximumBitrateUL_t : BitRate
+ {
+ static constexpr const char* name() {return "e_RAB_MaximumBitrateUL_t";}
+ using parent_t = BitRate;
+
+ };
+ e_RAB_MaximumBitrateUL_t& ref_e_RAB_MaximumBitrateUL() {return e_RAB_MaximumBitrateUL;}
+ e_RAB_MaximumBitrateUL_t const& ref_e_RAB_MaximumBitrateUL() const {return e_RAB_MaximumBitrateUL;}
+ struct e_RAB_GuaranteedBitrateDL_t : BitRate
+ {
+ static constexpr const char* name() {return "e_RAB_GuaranteedBitrateDL_t";}
+ using parent_t = BitRate;
+
+ };
+ e_RAB_GuaranteedBitrateDL_t& ref_e_RAB_GuaranteedBitrateDL() {return e_RAB_GuaranteedBitrateDL;}
+ e_RAB_GuaranteedBitrateDL_t const& ref_e_RAB_GuaranteedBitrateDL() const {return e_RAB_GuaranteedBitrateDL;}
+ struct e_RAB_GuaranteedBitrateUL_t : BitRate
+ {
+ static constexpr const char* name() {return "e_RAB_GuaranteedBitrateUL_t";}
+ using parent_t = BitRate;
+
+ };
+ e_RAB_GuaranteedBitrateUL_t& ref_e_RAB_GuaranteedBitrateUL() {return e_RAB_GuaranteedBitrateUL;}
+ e_RAB_GuaranteedBitrateUL_t const& ref_e_RAB_GuaranteedBitrateUL() const {return e_RAB_GuaranteedBitrateUL;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(e_RAB_MaximumBitrateDL);
+ v(e_RAB_MaximumBitrateUL);
+ v(e_RAB_GuaranteedBitrateDL);
+ v(e_RAB_GuaranteedBitrateUL);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(e_RAB_MaximumBitrateDL);
+ v(e_RAB_MaximumBitrateUL);
+ v(e_RAB_GuaranteedBitrateDL);
+ v(e_RAB_GuaranteedBitrateUL);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ e_RAB_MaximumBitrateDL.clear();
+ e_RAB_MaximumBitrateUL.clear();
+ e_RAB_GuaranteedBitrateDL.clear();
+ e_RAB_GuaranteedBitrateUL.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ e_RAB_MaximumBitrateDL_t e_RAB_MaximumBitrateDL;
+ e_RAB_MaximumBitrateUL_t e_RAB_MaximumBitrateUL;
+ e_RAB_GuaranteedBitrateDL_t e_RAB_GuaranteedBitrateDL;
+ e_RAB_GuaranteedBitrateUL_t e_RAB_GuaranteedBitrateUL;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+Packet-LossRate ::= INTEGER(0..1000)
+*/
+
+struct Packet_LossRate : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 1000>>;
+ static constexpr const char* name() {return "Packet-LossRate";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+E-RAB-Level-QoS-Parameters-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extended for introduction of downlink and uplink packet loss rate for enhanced Voice performance –
+ { ID id-DownlinkPacketLossRate CRITICALITY ignore EXTENSION Packet-LossRate PRESENCE optional}|
+ { ID id-UplinkPacketLossRate CRITICALITY ignore EXTENSION Packet-LossRate PRESENCE optional},
+ ...
+}
+*/
+
+struct E_RAB_Level_QoS_Parameters_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DownlinkPacketLossRate() { set(id_DownlinkPacketLossRate); type=1;}
+ void select_id_UplinkPacketLossRate() { set(id_UplinkPacketLossRate); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_DownlinkPacketLossRate)) { type = 1; return true; }
+ else if(equal(id_UplinkPacketLossRate)) { 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_DownlinkPacketLossRate);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_UplinkPacketLossRate);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DownlinkPacketLossRate() { set(ignore); type=1;}
+ void select_id_UplinkPacketLossRate() { set(ignore); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { 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(ignore);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ Packet_LossRate& select_id_DownlinkPacketLossRate() { return set<Packet_LossRate>(1); }
+ Packet_LossRate const* get_id_DownlinkPacketLossRate() const { return get<Packet_LossRate>(1); }
+ Packet_LossRate& select_id_UplinkPacketLossRate() { return set<Packet_LossRate>(2); }
+ Packet_LossRate const* get_id_UplinkPacketLossRate() const { return get<Packet_LossRate>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<Packet_LossRate>(); break;
+ case 2: var.destroy<Packet_LossRate>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<Packet_LossRate>(1);
+ v.template operator()<Packet_LossRate>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_DownlinkPacketLossRate()); return true;
+ case 2: v(select_id_UplinkPacketLossRate()); 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<Packet_LossRate>()); return true;
+ case 2: v(var.as<Packet_LossRate>()); 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(Packet_LossRate)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DownlinkPacketLossRate() { set(optional); type=1;}
+ void select_id_UplinkPacketLossRate() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+E-RAB-Level-QoS-Parameters ::= SEQUENCE {
+ qCI QCI,
+ allocationAndRetentionPriority AllocationAndRetentionPriority,
+ gbrQosInformation GBR-QosInformation OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {E-RAB-Level-QoS-Parameters-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct E_RAB_Level_QoS_Parameters : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "E-RAB-Level-QoS-Parameters";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct qCI_t : QCI
+ {
+ static constexpr const char* name() {return "qCI_t";}
+ using parent_t = QCI;
+
+ };
+ qCI_t& ref_qCI() {return qCI;}
+ qCI_t const& ref_qCI() const {return qCI;}
+ struct allocationAndRetentionPriority_t : AllocationAndRetentionPriority
+ {
+ static constexpr const char* name() {return "allocationAndRetentionPriority_t";}
+ using parent_t = AllocationAndRetentionPriority;
+
+ };
+ allocationAndRetentionPriority_t& ref_allocationAndRetentionPriority() {return allocationAndRetentionPriority;}
+ allocationAndRetentionPriority_t const& ref_allocationAndRetentionPriority() const {return allocationAndRetentionPriority;}
+ struct gbrQosInformation_t : GBR_QosInformation
+ {
+ static constexpr const char* name() {return "gbrQosInformation_t";}
+ using parent_t = GBR_QosInformation;
+ static constexpr bool optional = true;
+
+ };
+ gbrQosInformation_t& set_gbrQosInformation() { gbrQosInformation.setpresent(true); return gbrQosInformation;}
+ gbrQosInformation_t const* get_gbrQosInformation() const {return gbrQosInformation.is_valid() ? &gbrQosInformation : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(qCI);
+ v(allocationAndRetentionPriority);
+ v(gbrQosInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(qCI);
+ v(allocationAndRetentionPriority);
+ v(gbrQosInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ qCI.clear();
+ allocationAndRetentionPriority.clear();
+ gbrQosInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ qCI_t qCI;
+ allocationAndRetentionPriority_t allocationAndRetentionPriority;
+ gbrQosInformation_t gbrQosInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+E-RAB-List ::= SEQUENCE (SIZE(1.. maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RAB-ItemIEs} }
+*/
+
+struct E_RAB_List_elm : ProtocolIE_Single_Container<E_RAB_ItemIEs>
+{
+ static constexpr const char* name() {return "E_RAB_List_elm";}
+ using parent_t = ProtocolIE_Single_Container<E_RAB_ItemIEs>;
+
+};
+struct E_RAB_List : asn::sequenceof<E_RAB_List_elm>
+{
+ static constexpr const char* name() {return "E-RAB-List";}
+ using parent_t = asn::sequenceof<E_RAB_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
+
+};
+/*
+E-RABUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct E_RABUsageReport_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+E-RABUsageReport-Item ::= SEQUENCE {
+ startTimeStamp OCTET STRING (SIZE(4)),
+ endTimeStamp OCTET STRING (SIZE(4)),
+ usageCountUL INTEGER (0..4294967295),
+ usageCountDL INTEGER (0..4294967295),
+ iE-Extensions ProtocolExtensionContainer { {E-RABUsageReport-Item-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct E_RABUsageReport_Item : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "E-RABUsageReport-Item";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct startTimeStamp_t : asn::ostring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<4>>;
+ static constexpr const char* name() {return "startTimeStamp_t";}
+ using parent_t = asn::ostring<>;
+
+ };
+
+ startTimeStamp_t& ref_startTimeStamp() {return startTimeStamp;}
+ startTimeStamp_t const& ref_startTimeStamp() const {return startTimeStamp;}
+ struct endTimeStamp_t : asn::ostring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<4>>;
+ static constexpr const char* name() {return "endTimeStamp_t";}
+ using parent_t = asn::ostring<>;
+
+ };
+
+ endTimeStamp_t& ref_endTimeStamp() {return endTimeStamp;}
+ endTimeStamp_t const& ref_endTimeStamp() const {return endTimeStamp;}
+ struct usageCountUL_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+ static constexpr const char* name() {return "usageCountUL_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ usageCountUL_t& ref_usageCountUL() {return usageCountUL;}
+ usageCountUL_t const& ref_usageCountUL() const {return usageCountUL;}
+ struct usageCountDL_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+ static constexpr const char* name() {return "usageCountDL_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ usageCountDL_t& ref_usageCountDL() {return usageCountDL;}
+ usageCountDL_t const& ref_usageCountDL() const {return usageCountDL;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(startTimeStamp);
+ v(endTimeStamp);
+ v(usageCountUL);
+ v(usageCountDL);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(startTimeStamp);
+ v(endTimeStamp);
+ v(usageCountUL);
+ v(usageCountDL);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ startTimeStamp.clear();
+ endTimeStamp.clear();
+ usageCountUL.clear();
+ usageCountDL.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ startTimeStamp_t startTimeStamp;
+ endTimeStamp_t endTimeStamp;
+ usageCountUL_t usageCountUL;
+ usageCountDL_t usageCountDL;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+E-RABUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
+ { ID id-E-RABUsageReport-Item CRITICALITY ignore TYPE E-RABUsageReport-Item PRESENCE mandatory },
+ ...
+}
+*/
+
+struct E_RABUsageReport_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_E_RABUsageReport_Item() { set(id_E_RABUsageReport_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_E_RABUsageReport_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_E_RABUsageReport_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_E_RABUsageReport_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;}
+ E_RABUsageReport_Item& select_id_E_RABUsageReport_Item() { return set<E_RABUsageReport_Item>(1); }
+ E_RABUsageReport_Item const* get_id_E_RABUsageReport_Item() const { return get<E_RABUsageReport_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<E_RABUsageReport_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<E_RABUsageReport_Item>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_E_RABUsageReport_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<E_RABUsageReport_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(E_RABUsageReport_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_E_RABUsageReport_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};
+
+ };
+
+};
+/*
+E-RABUsageReportList ::= SEQUENCE (SIZE(1..maxnooftimeperiods)) OF ProtocolIE-Single-Container { {E-RABUsageReport-ItemIEs} }
+*/
+
+struct E_RABUsageReportList_elm : ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>
+{
+ static constexpr const char* name() {return "E_RABUsageReportList_elm";}
+ using parent_t = ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>;
+
+};
+struct E_RABUsageReportList : asn::sequenceof<E_RABUsageReportList_elm>
+{
+ static constexpr const char* name() {return "E-RABUsageReportList";}
+ using parent_t = asn::sequenceof<E_RABUsageReportList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnooftimeperiods >>;
+
+};
+/*
+EARFCN ::= INTEGER (0..maxEARFCN)
+*/
+
+struct EARFCN : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, maxEARFCN >>;
+ static constexpr const char* name() {return "EARFCN";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+EARFCNExtension ::= INTEGER(maxEARFCNPlusOne..newmaxEARFCN, ...)
+*/
+
+struct EARFCNExtension : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span< maxEARFCNPlusOne , newmaxEARFCN >>;
+ static constexpr const char* name() {return "EARFCNExtension";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+EN-DC-ResourceConfigurationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct EN_DC_ResourceConfigurationExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+EN-DC-ResourceConfiguration ::= SEQUENCE {
+ pDCPatSgNB ENUMERATED {present, not-present, ...},
+ mCGresources ENUMERATED {present, not-present, ...},
+ sCGresources ENUMERATED {present, not-present, ...},
+ iE-Extensions ProtocolExtensionContainer { {EN-DC-ResourceConfigurationExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct EN_DC_ResourceConfiguration : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "EN-DC-ResourceConfiguration";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct pDCPatSgNB_t : asn::enumerated<2, 0, true>
+ {
+ static constexpr const char* name() {return "pDCPatSgNB_t";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ present
+ ,not_present
+ } index_t;
+
+ };
+
+ pDCPatSgNB_t& ref_pDCPatSgNB() {return pDCPatSgNB;}
+ pDCPatSgNB_t const& ref_pDCPatSgNB() const {return pDCPatSgNB;}
+ struct mCGresources_t : asn::enumerated<2, 0, true>
+ {
+ static constexpr const char* name() {return "mCGresources_t";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ present
+ ,not_present
+ } index_t;
+
+ };
+
+ mCGresources_t& ref_mCGresources() {return mCGresources;}
+ mCGresources_t const& ref_mCGresources() const {return mCGresources;}
+ struct sCGresources_t : asn::enumerated<2, 0, true>
+ {
+ static constexpr const char* name() {return "sCGresources_t";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ present
+ ,not_present
+ } index_t;
+
+ };
+
+ sCGresources_t& ref_sCGresources() {return sCGresources;}
+ sCGresources_t const& ref_sCGresources() const {return sCGresources;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pDCPatSgNB);
+ v(mCGresources);
+ v(sCGresources);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pDCPatSgNB);
+ v(mCGresources);
+ v(sCGresources);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pDCPatSgNB.clear();
+ mCGresources.clear();
+ sCGresources.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pDCPatSgNB_t pDCPatSgNB;
+ mCGresources_t mCGresources;
+ sCGresources_t sCGresources;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ENB-ID ::= CHOICE {
+ macro-eNB-ID BIT STRING (SIZE (20)),
+ home-eNB-ID BIT STRING (SIZE (28)),
+ ... ,
+ short-Macro-eNB-ID BIT STRING (SIZE(18)),
+ long-Macro-eNB-ID BIT STRING (SIZE(21))
+}
+*/
+
+struct ENB_ID : asn::choice<4, 2, true>
+{
+ static constexpr const char* name() {return "ENB-ID";}
+ using parent_t = asn::choice<4, 2, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~ENB_ID() {clear();}
+ struct macro_eNB_ID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<20>>;
+ static constexpr const char* name() {return "macro_eNB_ID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ struct home_eNB_ID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<28>>;
+ static constexpr const char* name() {return "home_eNB_ID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ struct short_Macro_eNB_ID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<18>>;
+ static constexpr const char* name() {return "short_Macro_eNB_ID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ struct long_Macro_eNB_ID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<21>>;
+ static constexpr const char* name() {return "long_Macro_eNB_ID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<macro_eNB_ID_t>(); break;
+ case 2: var.destroy<home_eNB_ID_t>(); break;
+ case 3: var.destroy<short_Macro_eNB_ID_t>(); break;
+ case 4: var.destroy<long_Macro_eNB_ID_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<macro_eNB_ID_t>());
+ case 2: set_index(2); return v(var.build<home_eNB_ID_t>());
+ case 3: set_index(3); return v(var.build<short_Macro_eNB_ID_t>());
+ case 4: set_index(4); return v(var.build<long_Macro_eNB_ID_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<macro_eNB_ID_t>());
+ case 2: return v(var.as<home_eNB_ID_t>());
+ case 3: return v(var.as<short_Macro_eNB_ID_t>());
+ case 4: return v(var.as<long_Macro_eNB_ID_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<macro_eNB_ID_t>(1);
+ v.template operator()<home_eNB_ID_t>(2);
+ v.template operator()<short_Macro_eNB_ID_t>(3);
+ v.template operator()<long_Macro_eNB_ID_t>(4);
+
+ }
+ macro_eNB_ID_t& select_macro_eNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<macro_eNB_ID_t>();} return var.as<macro_eNB_ID_t>();}
+ macro_eNB_ID_t const* get_macro_eNB_ID() const { if(get_index() == 1) { return &var.as<macro_eNB_ID_t>();} return nullptr; }
+ home_eNB_ID_t& select_home_eNB_ID() { if(get_index() != 2) { clear(); set_index(2); return var.build<home_eNB_ID_t>();} return var.as<home_eNB_ID_t>();}
+ home_eNB_ID_t const* get_home_eNB_ID() const { if(get_index() == 2) { return &var.as<home_eNB_ID_t>();} return nullptr; }
+ short_Macro_eNB_ID_t& select_short_Macro_eNB_ID() { if(get_index() != 3) { clear(); set_index(3); return var.build<short_Macro_eNB_ID_t>();} return var.as<short_Macro_eNB_ID_t>();}
+ short_Macro_eNB_ID_t const* get_short_Macro_eNB_ID() const { if(get_index() == 3) { return &var.as<short_Macro_eNB_ID_t>();} return nullptr; }
+ long_Macro_eNB_ID_t& select_long_Macro_eNB_ID() { if(get_index() != 4) { clear(); set_index(4); return var.build<long_Macro_eNB_ID_t>();} return var.as<long_Macro_eNB_ID_t>();}
+ long_Macro_eNB_ID_t const* get_long_Macro_eNB_ID() const { if(get_index() == 4) { return &var.as<long_Macro_eNB_ID_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(macro_eNB_ID_t)];
+ char dummy2[sizeof(home_eNB_ID_t)];
+ char dummy3[sizeof(short_Macro_eNB_ID_t)];
+ char dummy4[sizeof(long_Macro_eNB_ID_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+EPLMNs ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF PLMN-Identity
+*/
+
+struct EPLMNs_elm : PLMN_Identity
+{
+ static constexpr const char* name() {return "EPLMNs_elm";}
+ using parent_t = PLMN_Identity;
+
+};
+struct EPLMNs : asn::sequenceof<EPLMNs_elm>
+{
+ static constexpr const char* name() {return "EPLMNs";}
+ using parent_t = asn::sequenceof<EPLMNs_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNs >>;
+
+};
+/*
+UserPlaneTrafficActivityReport ::= ENUMERATED {inactive, re-activated, ...}
+*/
+
+struct UserPlaneTrafficActivityReport : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "UserPlaneTrafficActivityReport";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ inactive
+ ,re_activated
+ } index_t;
+
+};
+
+/*
+ERABActivityNotifyItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ERABActivityNotifyItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ERABActivityNotifyItem ::= SEQUENCE {
+ e-RAB-ID E-RAB-ID,
+ activityReport UserPlaneTrafficActivityReport,
+ iE-Extensions ProtocolExtensionContainer { {ERABActivityNotifyItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ERABActivityNotifyItem : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ERABActivityNotifyItem";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct e_RAB_ID_t : E_RAB_ID
+ {
+ static constexpr const char* name() {return "e_RAB_ID_t";}
+ using parent_t = E_RAB_ID;
+
+ };
+ e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+ e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+ struct activityReport_t : UserPlaneTrafficActivityReport
+ {
+ static constexpr const char* name() {return "activityReport_t";}
+ using parent_t = UserPlaneTrafficActivityReport;
+
+ };
+ activityReport_t& ref_activityReport() {return activityReport;}
+ activityReport_t const& ref_activityReport() const {return activityReport;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(e_RAB_ID);
+ v(activityReport);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(e_RAB_ID);
+ v(activityReport);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ e_RAB_ID.clear();
+ activityReport.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ e_RAB_ID_t e_RAB_ID;
+ activityReport_t activityReport;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ERABActivityNotifyItemList ::= SEQUENCE (SIZE (0..maxnoofBearers)) OF ERABActivityNotifyItem
+*/
+
+struct ERABActivityNotifyItemList_elm : ERABActivityNotifyItem
+{
+ static constexpr const char* name() {return "ERABActivityNotifyItemList_elm";}
+ using parent_t = ERABActivityNotifyItem;
+
+};
+struct ERABActivityNotifyItemList : asn::sequenceof<ERABActivityNotifyItemList_elm>
+{
+ static constexpr const char* name() {return "ERABActivityNotifyItemList";}
+ using parent_t = asn::sequenceof<ERABActivityNotifyItemList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxnoofBearers >>;
+
+};
+/*
+Transmission-Bandwidth ::= ENUMERATED {
+ bw6,
+ bw15,
+ bw25,
+ bw50,
+ bw75,
+ bw100,
+ ...,
+ bw1
+}
+*/
+
+struct Transmission_Bandwidth : asn::enumerated<7, 1, true>
+{
+ static constexpr const char* name() {return "Transmission-Bandwidth";}
+ using parent_t = asn::enumerated<7, 1, true>;
+ typedef enum {
+ bw6
+ ,bw15
+ ,bw25
+ ,bw50
+ ,bw75
+ ,bw100
+ ,bw1
+ } index_t;
+
+};
+
+/*
+OffsetOfNbiotChannelNumberToEARFCN ::= ENUMERATED {
+ minusTen,
+ minusNine,
+ minusEight,
+ minusSeven,
+ minusSix,
+ minusFive,
+ minusFour,
+ minusThree,
+ minusTwo,
+ minusOne,
+ minusZeroDotFive,
+ zero,
+ one,
+ two,
+ three,
+ four,
+ five,
+ six,
+ seven,
+ eight,
+ nine,
+ ...
+}
+*/
+
+struct OffsetOfNbiotChannelNumberToEARFCN : asn::enumerated<21, 0, true>
+{
+ static constexpr const char* name() {return "OffsetOfNbiotChannelNumberToEARFCN";}
+ using parent_t = asn::enumerated<21, 0, true>;
+ typedef enum {
+ minusTen
+ ,minusNine
+ ,minusEight
+ ,minusSeven
+ ,minusSix
+ ,minusFive
+ ,minusFour
+ ,minusThree
+ ,minusTwo
+ ,minusOne
+ ,minusZeroDotFive
+ ,zero
+ ,one
+ ,two
+ ,three
+ ,four
+ ,five
+ ,six
+ ,seven
+ ,eight
+ ,nine
+ } index_t;
+
+};
+
+/*
+NRS-NSSS-PowerOffset ::= ENUMERATED { minusThree, zero, three, ...}
+*/
+
+struct NRS_NSSS_PowerOffset : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "NRS-NSSS-PowerOffset";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ minusThree
+ ,zero
+ ,three
+ } index_t;
+
+};
+
+/*
+NSSS-NumOccasionDifferentPrecoder ::= ENUMERATED { two, four, eight, ...}
+*/
+
+struct NSSS_NumOccasionDifferentPrecoder : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "NSSS-NumOccasionDifferentPrecoder";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ two
+ ,four
+ ,eight
+ } index_t;
+
+};
+
+/*
+FDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-UL-EARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
+ { ID id-DL-EARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
+ { ID id-OffsetOfNbiotChannelNumberToDL-EARFCN CRITICALITY reject EXTENSION OffsetOfNbiotChannelNumberToEARFCN PRESENCE optional}|
+ { ID id-OffsetOfNbiotChannelNumberToUL-EARFCN CRITICALITY reject EXTENSION OffsetOfNbiotChannelNumberToEARFCN PRESENCE optional}|
+ { ID id-NRS-NSSS-PowerOffset CRITICALITY ignore EXTENSION NRS-NSSS-PowerOffset PRESENCE optional}|
+ { ID id-NSSS-NumOccasionDifferentPrecoder CRITICALITY ignore EXTENSION NSSS-NumOccasionDifferentPrecoder PRESENCE optional},
+ ...
+}
+*/
+
+struct FDD_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 7; }
+ void clear() {type = 0;}
+ void select_id_UL_EARFCNExtension() { set(id_UL_EARFCNExtension); type=1;}
+ void select_id_DL_EARFCNExtension() { set(id_DL_EARFCNExtension); type=2;}
+ void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToDL_EARFCN); type=3;}
+ void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToUL_EARFCN); type=4;}
+ void select_id_NRS_NSSS_PowerOffset() { set(id_NRS_NSSS_PowerOffset); type=5;}
+ void select_id_NSSS_NumOccasionDifferentPrecoder() { set(id_NSSS_NumOccasionDifferentPrecoder); type=6;}
+ X2AP_PROTOCOL_EXTENSION::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_UL_EARFCNExtension)) { type = 1; return true; }
+ else if(equal(id_DL_EARFCNExtension)) { type = 2; return true; }
+ else if(equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN)) { type = 3; return true; }
+ else if(equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN)) { type = 4; return true; }
+ else if(equal(id_NRS_NSSS_PowerOffset)) { type = 5; return true; }
+ else if(equal(id_NSSS_NumOccasionDifferentPrecoder)) { 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_UL_EARFCNExtension);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_DL_EARFCNExtension);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(id_NRS_NSSS_PowerOffset);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(id_NSSS_NumOccasionDifferentPrecoder);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 7; }
+ void clear() {type = 0;}
+ void select_id_UL_EARFCNExtension() { set(reject); type=1;}
+ void select_id_DL_EARFCNExtension() { set(reject); type=2;}
+ void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(reject); type=3;}
+ void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(reject); type=4;}
+ void select_id_NRS_NSSS_PowerOffset() { set(ignore); type=5;}
+ void select_id_NSSS_NumOccasionDifferentPrecoder() { set(ignore); type=6;}
+ X2AP_PROTOCOL_EXTENSION::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(ignore)) { type = 5; return true; }
+ else if(equal(ignore)) { 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(ignore);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ EARFCNExtension& select_id_UL_EARFCNExtension() { return set<EARFCNExtension>(1); }
+ EARFCNExtension const* get_id_UL_EARFCNExtension() const { return get<EARFCNExtension>(1); }
+ EARFCNExtension& select_id_DL_EARFCNExtension() { return set<EARFCNExtension>(2); }
+ EARFCNExtension const* get_id_DL_EARFCNExtension() const { return get<EARFCNExtension>(2); }
+ OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(3); }
+ OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToDL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(3); }
+ OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(4); }
+ OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToUL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(4); }
+ NRS_NSSS_PowerOffset& select_id_NRS_NSSS_PowerOffset() { return set<NRS_NSSS_PowerOffset>(5); }
+ NRS_NSSS_PowerOffset const* get_id_NRS_NSSS_PowerOffset() const { return get<NRS_NSSS_PowerOffset>(5); }
+ NSSS_NumOccasionDifferentPrecoder& select_id_NSSS_NumOccasionDifferentPrecoder() { return set<NSSS_NumOccasionDifferentPrecoder>(6); }
+ NSSS_NumOccasionDifferentPrecoder const* get_id_NSSS_NumOccasionDifferentPrecoder() const { return get<NSSS_NumOccasionDifferentPrecoder>(6); }
+ bool is_unknown() const { return type == 7; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<EARFCNExtension>(); break;
+ case 2: var.destroy<EARFCNExtension>(); break;
+ case 3: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
+ case 4: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
+ case 5: var.destroy<NRS_NSSS_PowerOffset>(); break;
+ case 6: var.destroy<NSSS_NumOccasionDifferentPrecoder>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<EARFCNExtension>(1);
+ v.template operator()<EARFCNExtension>(2);
+ v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(3);
+ v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(4);
+ v.template operator()<NRS_NSSS_PowerOffset>(5);
+ v.template operator()<NSSS_NumOccasionDifferentPrecoder>(6);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_UL_EARFCNExtension()); return true;
+ case 2: v(select_id_DL_EARFCNExtension()); return true;
+ case 3: v(select_id_OffsetOfNbiotChannelNumberToDL_EARFCN()); return true;
+ case 4: v(select_id_OffsetOfNbiotChannelNumberToUL_EARFCN()); return true;
+ case 5: v(select_id_NRS_NSSS_PowerOffset()); return true;
+ case 6: v(select_id_NSSS_NumOccasionDifferentPrecoder()); 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<EARFCNExtension>()); return true;
+ case 2: v(var.as<EARFCNExtension>()); return true;
+ case 3: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
+ case 4: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
+ case 5: v(var.as<NRS_NSSS_PowerOffset>()); return true;
+ case 6: v(var.as<NSSS_NumOccasionDifferentPrecoder>()); 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(EARFCNExtension)];
+ char dummy2[sizeof(NRS_NSSS_PowerOffset)];
+ char dummy3[sizeof(NSSS_NumOccasionDifferentPrecoder)];
+ char dummy4[sizeof(OffsetOfNbiotChannelNumberToEARFCN)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 7; }
+ void clear() {type = 0;}
+ void select_id_UL_EARFCNExtension() { set(optional); type=1;}
+ void select_id_DL_EARFCNExtension() { set(optional); type=2;}
+ void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(optional); type=3;}
+ void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(optional); type=4;}
+ void select_id_NRS_NSSS_PowerOffset() { set(optional); type=5;}
+ void select_id_NSSS_NumOccasionDifferentPrecoder() { set(optional); type=6;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(optional)) { type = 4; return true; }
+ else if(equal(optional)) { 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(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; if(v(ref_nested())) { return equal(optional);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(optional);} 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};
+
+ };
+
+};
+/*
+FDD-Info ::= SEQUENCE {
+ uL-EARFCN EARFCN,
+ dL-EARFCN EARFCN,
+ uL-Transmission-Bandwidth Transmission-Bandwidth,
+ dL-Transmission-Bandwidth Transmission-Bandwidth,
+ iE-Extensions ProtocolExtensionContainer { {FDD-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct FDD_Info : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "FDD-Info";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct uL_EARFCN_t : EARFCN
+ {
+ static constexpr const char* name() {return "uL_EARFCN_t";}
+ using parent_t = EARFCN;
+
+ };
+ uL_EARFCN_t& ref_uL_EARFCN() {return uL_EARFCN;}
+ uL_EARFCN_t const& ref_uL_EARFCN() const {return uL_EARFCN;}
+ struct dL_EARFCN_t : EARFCN
+ {
+ static constexpr const char* name() {return "dL_EARFCN_t";}
+ using parent_t = EARFCN;
+
+ };
+ dL_EARFCN_t& ref_dL_EARFCN() {return dL_EARFCN;}
+ dL_EARFCN_t const& ref_dL_EARFCN() const {return dL_EARFCN;}
+ struct uL_Transmission_Bandwidth_t : Transmission_Bandwidth
+ {
+ static constexpr const char* name() {return "uL_Transmission_Bandwidth_t";}
+ using parent_t = Transmission_Bandwidth;
+
+ };
+ uL_Transmission_Bandwidth_t& ref_uL_Transmission_Bandwidth() {return uL_Transmission_Bandwidth;}
+ uL_Transmission_Bandwidth_t const& ref_uL_Transmission_Bandwidth() const {return uL_Transmission_Bandwidth;}
+ struct dL_Transmission_Bandwidth_t : Transmission_Bandwidth
+ {
+ static constexpr const char* name() {return "dL_Transmission_Bandwidth_t";}
+ using parent_t = Transmission_Bandwidth;
+
+ };
+ dL_Transmission_Bandwidth_t& ref_dL_Transmission_Bandwidth() {return dL_Transmission_Bandwidth;}
+ dL_Transmission_Bandwidth_t const& ref_dL_Transmission_Bandwidth() const {return dL_Transmission_Bandwidth;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<FDD_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<FDD_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uL_EARFCN);
+ v(dL_EARFCN);
+ v(uL_Transmission_Bandwidth);
+ v(dL_Transmission_Bandwidth);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uL_EARFCN);
+ v(dL_EARFCN);
+ v(uL_Transmission_Bandwidth);
+ v(dL_Transmission_Bandwidth);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uL_EARFCN.clear();
+ dL_EARFCN.clear();
+ uL_Transmission_Bandwidth.clear();
+ dL_Transmission_Bandwidth.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uL_EARFCN_t uL_EARFCN;
+ dL_EARFCN_t dL_EARFCN;
+ uL_Transmission_Bandwidth_t uL_Transmission_Bandwidth;
+ dL_Transmission_Bandwidth_t dL_Transmission_Bandwidth;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SubframeAssignment ::= ENUMERATED {
+ sa0,
+ sa1,
+ sa2,
+ sa3,
+ sa4,
+ sa5,
+ sa6,
+ ...
+}
+*/
+
+struct SubframeAssignment : asn::enumerated<7, 0, true>
+{
+ static constexpr const char* name() {return "SubframeAssignment";}
+ using parent_t = asn::enumerated<7, 0, true>;
+ typedef enum {
+ sa0
+ ,sa1
+ ,sa2
+ ,sa3
+ ,sa4
+ ,sa5
+ ,sa6
+ } index_t;
+
+};
+
+/*
+SpecialSubframePatterns ::= ENUMERATED {
+ ssp0,
+ ssp1,
+ ssp2,
+ ssp3,
+ ssp4,
+ ssp5,
+ ssp6,
+ ssp7,
+ ssp8,
+ ...
+}
+*/
+
+struct SpecialSubframePatterns : asn::enumerated<9, 0, true>
+{
+ static constexpr const char* name() {return "SpecialSubframePatterns";}
+ using parent_t = asn::enumerated<9, 0, true>;
+ typedef enum {
+ ssp0
+ ,ssp1
+ ,ssp2
+ ,ssp3
+ ,ssp4
+ ,ssp5
+ ,ssp6
+ ,ssp7
+ ,ssp8
+ } index_t;
+
+};
+
+/*
+SpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SpecialSubframe_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SpecialSubframe-Info ::= SEQUENCE {
+ specialSubframePatterns SpecialSubframePatterns,
+ cyclicPrefixDL CyclicPrefixDL,
+ cyclicPrefixUL CyclicPrefixUL,
+ iE-Extensions ProtocolExtensionContainer { {SpecialSubframe-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SpecialSubframe_Info : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "SpecialSubframe-Info";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct specialSubframePatterns_t : SpecialSubframePatterns
+ {
+ static constexpr const char* name() {return "specialSubframePatterns_t";}
+ using parent_t = SpecialSubframePatterns;
+
+ };
+ specialSubframePatterns_t& ref_specialSubframePatterns() {return specialSubframePatterns;}
+ specialSubframePatterns_t const& ref_specialSubframePatterns() const {return specialSubframePatterns;}
+ struct cyclicPrefixDL_t : CyclicPrefixDL
+ {
+ static constexpr const char* name() {return "cyclicPrefixDL_t";}
+ using parent_t = CyclicPrefixDL;
+
+ };
+ cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
+ cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
+ struct cyclicPrefixUL_t : CyclicPrefixUL
+ {
+ static constexpr const char* name() {return "cyclicPrefixUL_t";}
+ using parent_t = CyclicPrefixUL;
+
+ };
+ cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
+ cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(specialSubframePatterns);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(specialSubframePatterns);
+ v(cyclicPrefixDL);
+ v(cyclicPrefixUL);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ specialSubframePatterns.clear();
+ cyclicPrefixDL.clear();
+ cyclicPrefixUL.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ specialSubframePatterns_t specialSubframePatterns;
+ cyclicPrefixDL_t cyclicPrefixDL;
+ cyclicPrefixUL_t cyclicPrefixUL;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-AdditionalSpecialSubframe-Info CRITICALITY ignore EXTENSION AdditionalSpecialSubframe-Info PRESENCE optional}|
+ { ID id-eARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
+ { ID id-AdditionalSpecialSubframeExtension-Info CRITICALITY ignore EXTENSION AdditionalSpecialSubframeExtension-Info PRESENCE optional},
+ ...
+}
+*/
+
+struct TDD_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_AdditionalSpecialSubframe_Info() { set(id_AdditionalSpecialSubframe_Info); type=1;}
+ void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
+ void select_id_AdditionalSpecialSubframeExtension_Info() { set(id_AdditionalSpecialSubframeExtension_Info); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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_AdditionalSpecialSubframe_Info)) { type = 1; return true; }
+ else if(equal(id_eARFCNExtension)) { type = 2; return true; }
+ else if(equal(id_AdditionalSpecialSubframeExtension_Info)) { 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_AdditionalSpecialSubframe_Info);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframeExtension_Info);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_AdditionalSpecialSubframe_Info() { set(ignore); type=1;}
+ void select_id_eARFCNExtension() { set(reject); type=2;}
+ void select_id_AdditionalSpecialSubframeExtension_Info() { set(ignore); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(reject)) { 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(ignore);} 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(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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ AdditionalSpecialSubframe_Info& select_id_AdditionalSpecialSubframe_Info() { return set<AdditionalSpecialSubframe_Info>(1); }
+ AdditionalSpecialSubframe_Info const* get_id_AdditionalSpecialSubframe_Info() const { return get<AdditionalSpecialSubframe_Info>(1); }
+ EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
+ EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
+ AdditionalSpecialSubframeExtension_Info& select_id_AdditionalSpecialSubframeExtension_Info() { return set<AdditionalSpecialSubframeExtension_Info>(3); }
+ AdditionalSpecialSubframeExtension_Info const* get_id_AdditionalSpecialSubframeExtension_Info() const { return get<AdditionalSpecialSubframeExtension_Info>(3); }
+ bool is_unknown() const { return type == 4; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<AdditionalSpecialSubframe_Info>(); break;
+ case 2: var.destroy<EARFCNExtension>(); break;
+ case 3: var.destroy<AdditionalSpecialSubframeExtension_Info>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<AdditionalSpecialSubframe_Info>(1);
+ v.template operator()<EARFCNExtension>(2);
+ v.template operator()<AdditionalSpecialSubframeExtension_Info>(3);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_AdditionalSpecialSubframe_Info()); return true;
+ case 2: v(select_id_eARFCNExtension()); return true;
+ case 3: v(select_id_AdditionalSpecialSubframeExtension_Info()); 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<AdditionalSpecialSubframe_Info>()); return true;
+ case 2: v(var.as<EARFCNExtension>()); return true;
+ case 3: v(var.as<AdditionalSpecialSubframeExtension_Info>()); 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(AdditionalSpecialSubframeExtension_Info)];
+ char dummy2[sizeof(AdditionalSpecialSubframe_Info)];
+ char dummy3[sizeof(EARFCNExtension)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_AdditionalSpecialSubframe_Info() { set(optional); type=1;}
+ void select_id_eARFCNExtension() { set(optional); type=2;}
+ void select_id_AdditionalSpecialSubframeExtension_Info() { set(optional); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+TDD-Info ::= SEQUENCE {
+ eARFCN EARFCN,
+ transmission-Bandwidth Transmission-Bandwidth,
+ subframeAssignment SubframeAssignment,
+ specialSubframe-Info SpecialSubframe-Info,
+ iE-Extensions ProtocolExtensionContainer { {TDD-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TDD_Info : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "TDD-Info";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct eARFCN_t : EARFCN
+ {
+ static constexpr const char* name() {return "eARFCN_t";}
+ using parent_t = EARFCN;
+
+ };
+ eARFCN_t& ref_eARFCN() {return eARFCN;}
+ eARFCN_t const& ref_eARFCN() const {return eARFCN;}
+ struct transmission_Bandwidth_t : Transmission_Bandwidth
+ {
+ static constexpr const char* name() {return "transmission_Bandwidth_t";}
+ using parent_t = Transmission_Bandwidth;
+
+ };
+ transmission_Bandwidth_t& ref_transmission_Bandwidth() {return transmission_Bandwidth;}
+ transmission_Bandwidth_t const& ref_transmission_Bandwidth() const {return transmission_Bandwidth;}
+ struct subframeAssignment_t : SubframeAssignment
+ {
+ static constexpr const char* name() {return "subframeAssignment_t";}
+ using parent_t = SubframeAssignment;
+
+ };
+ subframeAssignment_t& ref_subframeAssignment() {return subframeAssignment;}
+ subframeAssignment_t const& ref_subframeAssignment() const {return subframeAssignment;}
+ struct specialSubframe_Info_t : SpecialSubframe_Info
+ {
+ static constexpr const char* name() {return "specialSubframe_Info_t";}
+ using parent_t = SpecialSubframe_Info;
+
+ };
+ specialSubframe_Info_t& ref_specialSubframe_Info() {return specialSubframe_Info;}
+ specialSubframe_Info_t const& ref_specialSubframe_Info() const {return specialSubframe_Info;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TDD_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TDD_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eARFCN);
+ v(transmission_Bandwidth);
+ v(subframeAssignment);
+ v(specialSubframe_Info);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eARFCN);
+ v(transmission_Bandwidth);
+ v(subframeAssignment);
+ v(specialSubframe_Info);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ eARFCN.clear();
+ transmission_Bandwidth.clear();
+ subframeAssignment.clear();
+ specialSubframe_Info.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ eARFCN_t eARFCN;
+ transmission_Bandwidth_t transmission_Bandwidth;
+ subframeAssignment_t subframeAssignment;
+ specialSubframe_Info_t specialSubframe_Info;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+EUTRA-Mode-Info ::= CHOICE {
+ fDD FDD-Info,
+ tDD TDD-Info,
+ ...
+}
+*/
+
+struct EUTRA_Mode_Info : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "EUTRA-Mode-Info";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~EUTRA_Mode_Info() {clear();}
+ struct fDD_t : FDD_Info
+ {
+ static constexpr const char* name() {return "fDD_t";}
+ using parent_t = FDD_Info;
+
+ };
+ struct tDD_t : TDD_Info
+ {
+ static constexpr const char* name() {return "tDD_t";}
+ using parent_t = TDD_Info;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<fDD_t>(); break;
+ case 2: var.destroy<tDD_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<fDD_t>());
+ case 2: set_index(2); return v(var.build<tDD_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<fDD_t>());
+ case 2: return v(var.as<tDD_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<fDD_t>(1);
+ v.template operator()<tDD_t>(2);
+
+ }
+ fDD_t& select_fDD() { if(get_index() != 1) { clear(); set_index(1); return var.build<fDD_t>();} return var.as<fDD_t>();}
+ fDD_t const* get_fDD() const { if(get_index() == 1) { return &var.as<fDD_t>();} return nullptr; }
+ tDD_t& select_tDD() { if(get_index() != 2) { clear(); set_index(2); return var.build<tDD_t>();} return var.as<tDD_t>();}
+ tDD_t const* get_tDD() const { if(get_index() == 2) { return &var.as<tDD_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(fDD_t)];
+ char dummy2[sizeof(tDD_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+EUTRANTraceID ::= OCTET STRING (SIZE (8))
+*/
+
+struct EUTRANTraceID : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<8>>;
+ static constexpr const char* name() {return "EUTRANTraceID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+EncryptionAlgorithms ::= BIT STRING (SIZE (16, ...))
+*/
+
+struct EncryptionAlgorithms : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::one<16>>;
+ static constexpr const char* name() {return "EncryptionAlgorithms";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+RNTP-Threshold ::= ENUMERATED {
+ minusInfinity,
+ minusEleven,
+ minusTen,
+ minusNine,
+ minusEight,
+ minusSeven,
+ minusSix,
+ minusFive,
+ minusFour,
+ minusThree,
+ minusTwo,
+ minusOne,
+ zero,
+ one,
+ two,
+ three,
+ ...
+}
+*/
+
+struct RNTP_Threshold : asn::enumerated<16, 0, true>
+{
+ static constexpr const char* name() {return "RNTP-Threshold";}
+ using parent_t = asn::enumerated<16, 0, true>;
+ typedef enum {
+ minusInfinity
+ ,minusEleven
+ ,minusTen
+ ,minusNine
+ ,minusEight
+ ,minusSeven
+ ,minusSix
+ ,minusFive
+ ,minusFour
+ ,minusThree
+ ,minusTwo
+ ,minusOne
+ ,zero
+ ,one
+ ,two
+ ,three
+ } index_t;
+
+};
+
+/*
+EnhancedRNTPStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct EnhancedRNTPStartTime_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+EnhancedRNTPStartTime ::= SEQUENCE {
+ startSFN INTEGER (0..1023, ...),
+ startSubframeNumber INTEGER (0..9, ...),
+ iE-Extensions ProtocolExtensionContainer { {EnhancedRNTPStartTime-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct EnhancedRNTPStartTime : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "EnhancedRNTPStartTime";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct startSFN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
+ static constexpr const char* name() {return "startSFN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ startSFN_t& ref_startSFN() {return startSFN;}
+ startSFN_t const& ref_startSFN() const {return startSFN;}
+ struct startSubframeNumber_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 9>>;
+ static constexpr const char* name() {return "startSubframeNumber_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
+ startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(startSFN);
+ v(startSubframeNumber);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(startSFN);
+ v(startSubframeNumber);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ startSFN.clear();
+ startSubframeNumber.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ startSFN_t startSFN;
+ startSubframeNumber_t startSubframeNumber;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+EnhancedRNTP-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct EnhancedRNTP_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+EnhancedRNTP ::= SEQUENCE {
+ enhancedRNTPBitmap BIT STRING (SIZE(12..8800, ...)),
+ rNTP-High-Power-Threshold RNTP-Threshold,
+ enhancedRNTPStartTime EnhancedRNTPStartTime OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {EnhancedRNTP-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct EnhancedRNTP : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "EnhancedRNTP";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct enhancedRNTPBitmap_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<12, 8800>>;
+ static constexpr const char* name() {return "enhancedRNTPBitmap_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ enhancedRNTPBitmap_t& ref_enhancedRNTPBitmap() {return enhancedRNTPBitmap;}
+ enhancedRNTPBitmap_t const& ref_enhancedRNTPBitmap() const {return enhancedRNTPBitmap;}
+ struct rNTP_High_Power_Threshold_t : RNTP_Threshold
+ {
+ static constexpr const char* name() {return "rNTP_High_Power_Threshold_t";}
+ using parent_t = RNTP_Threshold;
+
+ };
+ rNTP_High_Power_Threshold_t& ref_rNTP_High_Power_Threshold() {return rNTP_High_Power_Threshold;}
+ rNTP_High_Power_Threshold_t const& ref_rNTP_High_Power_Threshold() const {return rNTP_High_Power_Threshold;}
+ struct enhancedRNTPStartTime_t : EnhancedRNTPStartTime
+ {
+ static constexpr const char* name() {return "enhancedRNTPStartTime_t";}
+ using parent_t = EnhancedRNTPStartTime;
+ static constexpr bool optional = true;
+
+ };
+ enhancedRNTPStartTime_t& set_enhancedRNTPStartTime() { enhancedRNTPStartTime.setpresent(true); return enhancedRNTPStartTime;}
+ enhancedRNTPStartTime_t const* get_enhancedRNTPStartTime() const {return enhancedRNTPStartTime.is_valid() ? &enhancedRNTPStartTime : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(enhancedRNTPBitmap);
+ v(rNTP_High_Power_Threshold);
+ v(enhancedRNTPStartTime);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(enhancedRNTPBitmap);
+ v(rNTP_High_Power_Threshold);
+ v(enhancedRNTPStartTime);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ enhancedRNTPBitmap.clear();
+ rNTP_High_Power_Threshold.clear();
+ enhancedRNTPStartTime.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ enhancedRNTPBitmap_t enhancedRNTPBitmap;
+ rNTP_High_Power_Threshold_t rNTP_High_Power_Threshold;
+ enhancedRNTPStartTime_t enhancedRNTPStartTime;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+EventType ::= ENUMERATED{
+ change-of-serving-cell,
+ ...
+}
+*/
+
+struct EventType : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "EventType";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ change_of_serving_cell
+ } index_t;
+
+};
+
+/*
+ExpectedActivityPeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
+*/
+
+struct ExpectedActivityPeriod : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
+ static constexpr const char* name() {return "ExpectedActivityPeriod";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+ExpectedHOInterval ::= ENUMERATED {
+ sec15, sec30, sec60, sec90, sec120, sec180, long-time,
+ ...
+}
+*/
+
+struct ExpectedHOInterval : asn::enumerated<7, 0, true>
+{
+ static constexpr const char* name() {return "ExpectedHOInterval";}
+ using parent_t = asn::enumerated<7, 0, true>;
+ typedef enum {
+ sec15
+ ,sec30
+ ,sec60
+ ,sec90
+ ,sec120
+ ,sec180
+ ,long_time
+ } index_t;
+
+};
+
+/*
+ExpectedIdlePeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
+*/
+
+struct ExpectedIdlePeriod : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
+ static constexpr const char* name() {return "ExpectedIdlePeriod";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+SourceOfUEActivityBehaviourInformation ::= ENUMERATED {
+ subscription-information,
+ statistics,
+ ...
+}
+*/
+
+struct SourceOfUEActivityBehaviourInformation : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "SourceOfUEActivityBehaviourInformation";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ subscription_information
+ ,statistics
+ } index_t;
+
+};
+
+/*
+ExpectedUEActivityBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ExpectedUEActivityBehaviour_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ExpectedUEActivityBehaviour ::= SEQUENCE {
+ expectedActivityPeriod ExpectedActivityPeriod OPTIONAL,
+ expectedIdlePeriod ExpectedIdlePeriod OPTIONAL,
+ sourceofUEActivityBehaviourInformation SourceOfUEActivityBehaviourInformation OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {ExpectedUEActivityBehaviour-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ExpectedUEActivityBehaviour : asn::sequence<4, 0, true, 4>
+{
+ static constexpr const char* name() {return "ExpectedUEActivityBehaviour";}
+ using parent_t = asn::sequence<4, 0, true, 4>;
+ struct expectedActivityPeriod_t : ExpectedActivityPeriod
+ {
+ static constexpr const char* name() {return "expectedActivityPeriod_t";}
+ using parent_t = ExpectedActivityPeriod;
+ static constexpr bool optional = true;
+
+ };
+ expectedActivityPeriod_t& set_expectedActivityPeriod() { expectedActivityPeriod.setpresent(true); return expectedActivityPeriod;}
+ expectedActivityPeriod_t const* get_expectedActivityPeriod() const {return expectedActivityPeriod.is_valid() ? &expectedActivityPeriod : nullptr;}
+ struct expectedIdlePeriod_t : ExpectedIdlePeriod
+ {
+ static constexpr const char* name() {return "expectedIdlePeriod_t";}
+ using parent_t = ExpectedIdlePeriod;
+ static constexpr bool optional = true;
+
+ };
+ expectedIdlePeriod_t& set_expectedIdlePeriod() { expectedIdlePeriod.setpresent(true); return expectedIdlePeriod;}
+ expectedIdlePeriod_t const* get_expectedIdlePeriod() const {return expectedIdlePeriod.is_valid() ? &expectedIdlePeriod : nullptr;}
+ struct sourceofUEActivityBehaviourInformation_t : SourceOfUEActivityBehaviourInformation
+ {
+ static constexpr const char* name() {return "sourceofUEActivityBehaviourInformation_t";}
+ using parent_t = SourceOfUEActivityBehaviourInformation;
+ static constexpr bool optional = true;
+
+ };
+ sourceofUEActivityBehaviourInformation_t& set_sourceofUEActivityBehaviourInformation() { sourceofUEActivityBehaviourInformation.setpresent(true); return sourceofUEActivityBehaviourInformation;}
+ sourceofUEActivityBehaviourInformation_t const* get_sourceofUEActivityBehaviourInformation() const {return sourceofUEActivityBehaviourInformation.is_valid() ? &sourceofUEActivityBehaviourInformation : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(expectedActivityPeriod);
+ v(expectedIdlePeriod);
+ v(sourceofUEActivityBehaviourInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(expectedActivityPeriod);
+ v(expectedIdlePeriod);
+ v(sourceofUEActivityBehaviourInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ expectedActivityPeriod.clear();
+ expectedIdlePeriod.clear();
+ sourceofUEActivityBehaviourInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ expectedActivityPeriod_t expectedActivityPeriod;
+ expectedIdlePeriod_t expectedIdlePeriod;
+ sourceofUEActivityBehaviourInformation_t sourceofUEActivityBehaviourInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ExpectedUEBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ExpectedUEBehaviour_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ExpectedUEBehaviour ::= SEQUENCE {
+ expectedActivity ExpectedUEActivityBehaviour OPTIONAL,
+ expectedHOInterval ExpectedHOInterval OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {ExpectedUEBehaviour-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ExpectedUEBehaviour : asn::sequence<3, 0, true, 3>
+{
+ static constexpr const char* name() {return "ExpectedUEBehaviour";}
+ using parent_t = asn::sequence<3, 0, true, 3>;
+ struct expectedActivity_t : ExpectedUEActivityBehaviour
+ {
+ static constexpr const char* name() {return "expectedActivity_t";}
+ using parent_t = ExpectedUEActivityBehaviour;
+ static constexpr bool optional = true;
+
+ };
+ expectedActivity_t& set_expectedActivity() { expectedActivity.setpresent(true); return expectedActivity;}
+ expectedActivity_t const* get_expectedActivity() const {return expectedActivity.is_valid() ? &expectedActivity : nullptr;}
+ struct expectedHOInterval_t : ExpectedHOInterval
+ {
+ static constexpr const char* name() {return "expectedHOInterval_t";}
+ using parent_t = ExpectedHOInterval;
+ static constexpr bool optional = true;
+
+ };
+ expectedHOInterval_t& set_expectedHOInterval() { expectedHOInterval.setpresent(true); return expectedHOInterval;}
+ expectedHOInterval_t const* get_expectedHOInterval() const {return expectedHOInterval.is_valid() ? &expectedHOInterval : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(expectedActivity);
+ v(expectedHOInterval);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(expectedActivity);
+ v(expectedHOInterval);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ expectedActivity.clear();
+ expectedHOInterval.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ expectedActivity_t expectedActivity;
+ expectedHOInterval_t expectedHOInterval;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UL-InterferenceOverloadIndication-Item ::= ENUMERATED {
+ high-interference,
+ medium-interference,
+ low-interference,
+ ...
+}
+*/
+
+struct UL_InterferenceOverloadIndication_Item : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "UL-InterferenceOverloadIndication-Item";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ high_interference
+ ,medium_interference
+ ,low_interference
+ } index_t;
+
+};
+
+/*
+UL-InterferenceOverloadIndication ::= SEQUENCE (SIZE(1..maxnoofPRBs)) OF UL-InterferenceOverloadIndication-Item
+*/
+
+struct UL_InterferenceOverloadIndication_elm : UL_InterferenceOverloadIndication_Item
+{
+ static constexpr const char* name() {return "UL_InterferenceOverloadIndication_elm";}
+ using parent_t = UL_InterferenceOverloadIndication_Item;
+
+};
+struct UL_InterferenceOverloadIndication : asn::sequenceof<UL_InterferenceOverloadIndication_elm>
+{
+ static constexpr const char* name() {return "UL-InterferenceOverloadIndication";}
+ using parent_t = asn::sequenceof<UL_InterferenceOverloadIndication_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofPRBs >>;
+
+};
+/*
+ExtendedULInterferenceOverloadInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ExtendedULInterferenceOverloadInfo_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ExtendedULInterferenceOverloadInfo ::= SEQUENCE {
+ associatedSubframes BIT STRING (SIZE (5)),
+ extended-ul-InterferenceOverloadIndication UL-InterferenceOverloadIndication,
+ iE-Extensions ProtocolExtensionContainer { {ExtendedULInterferenceOverloadInfo-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ExtendedULInterferenceOverloadInfo : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ExtendedULInterferenceOverloadInfo";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct associatedSubframes_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<5>>;
+ static constexpr const char* name() {return "associatedSubframes_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ associatedSubframes_t& ref_associatedSubframes() {return associatedSubframes;}
+ associatedSubframes_t const& ref_associatedSubframes() const {return associatedSubframes;}
+ struct extended_ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
+ {
+ static constexpr const char* name() {return "extended_ul_InterferenceOverloadIndication_t";}
+ using parent_t = UL_InterferenceOverloadIndication;
+
+ };
+ extended_ul_InterferenceOverloadIndication_t& ref_extended_ul_InterferenceOverloadIndication() {return extended_ul_InterferenceOverloadIndication;}
+ extended_ul_InterferenceOverloadIndication_t const& ref_extended_ul_InterferenceOverloadIndication() const {return extended_ul_InterferenceOverloadIndication;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(associatedSubframes);
+ v(extended_ul_InterferenceOverloadIndication);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(associatedSubframes);
+ v(extended_ul_InterferenceOverloadIndication);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ associatedSubframes.clear();
+ extended_ul_InterferenceOverloadIndication.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ associatedSubframes_t associatedSubframes;
+ extended_ul_InterferenceOverloadIndication_t extended_ul_InterferenceOverloadIndication;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+FiveGS-TAC ::= OCTET STRING (SIZE (3))
+*/
+
+struct FiveGS_TAC : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<3>>;
+ static constexpr const char* name() {return "FiveGS-TAC";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+ForbiddenInterRATs ::= ENUMERATED {
+ all,
+ geran,
+ utran,
+ cdma2000,
+ ...,
+ geranandutran,
+ cdma2000andutran
+
+}
+*/
+
+struct ForbiddenInterRATs : asn::enumerated<6, 2, true>
+{
+ static constexpr const char* name() {return "ForbiddenInterRATs";}
+ using parent_t = asn::enumerated<6, 2, true>;
+ typedef enum {
+ all
+ ,geran
+ ,utran
+ ,cdma2000
+ ,geranandutran
+ ,cdma2000andutran
+ } index_t;
+
+};
+
+/*
+LAC ::= OCTET STRING (SIZE (2)) --(EXCEPT ('0000'H|'FFFE'H))
+*/
+
+struct LAC : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<2>>;
+ static constexpr const char* name() {return "LAC";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+ForbiddenLACs ::= SEQUENCE (SIZE(1..maxnoofForbLACs)) OF LAC
+*/
+
+struct ForbiddenLACs_elm : LAC
+{
+ static constexpr const char* name() {return "ForbiddenLACs_elm";}
+ using parent_t = LAC;
+
+};
+struct ForbiddenLACs : asn::sequenceof<ForbiddenLACs_elm>
+{
+ static constexpr const char* name() {return "ForbiddenLACs";}
+ using parent_t = asn::sequenceof<ForbiddenLACs_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofForbLACs >>;
+
+};
+/*
+ForbiddenLAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ForbiddenLAs_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ForbiddenLAs-Item ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ forbiddenLACs ForbiddenLACs,
+ iE-Extensions ProtocolExtensionContainer { {ForbiddenLAs-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ForbiddenLAs_Item : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ForbiddenLAs-Item";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct forbiddenLACs_t : ForbiddenLACs
+ {
+ static constexpr const char* name() {return "forbiddenLACs_t";}
+ using parent_t = ForbiddenLACs;
+
+ };
+ forbiddenLACs_t& ref_forbiddenLACs() {return forbiddenLACs;}
+ forbiddenLACs_t const& ref_forbiddenLACs() const {return forbiddenLACs;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(forbiddenLACs);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(forbiddenLACs);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ forbiddenLACs.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ forbiddenLACs_t forbiddenLACs;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ForbiddenLAs ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF ForbiddenLAs-Item
+*/
+
+struct ForbiddenLAs_elm : ForbiddenLAs_Item
+{
+ static constexpr const char* name() {return "ForbiddenLAs_elm";}
+ using parent_t = ForbiddenLAs_Item;
+
+};
+struct ForbiddenLAs : asn::sequenceof<ForbiddenLAs_elm>
+{
+ static constexpr const char* name() {return "ForbiddenLAs";}
+ using parent_t = asn::sequenceof<ForbiddenLAs_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+ForbiddenTACs ::= SEQUENCE (SIZE(1..maxnoofForbTACs)) OF TAC
+*/
+
+struct ForbiddenTACs_elm : TAC
+{
+ static constexpr const char* name() {return "ForbiddenTACs_elm";}
+ using parent_t = TAC;
+
+};
+struct ForbiddenTACs : asn::sequenceof<ForbiddenTACs_elm>
+{
+ static constexpr const char* name() {return "ForbiddenTACs";}
+ using parent_t = asn::sequenceof<ForbiddenTACs_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofForbTACs >>;
+
+};
+/*
+ForbiddenTAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ForbiddenTAs_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ForbiddenTAs-Item ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ forbiddenTACs ForbiddenTACs,
+ iE-Extensions ProtocolExtensionContainer { {ForbiddenTAs-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ForbiddenTAs_Item : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ForbiddenTAs-Item";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct forbiddenTACs_t : ForbiddenTACs
+ {
+ static constexpr const char* name() {return "forbiddenTACs_t";}
+ using parent_t = ForbiddenTACs;
+
+ };
+ forbiddenTACs_t& ref_forbiddenTACs() {return forbiddenTACs;}
+ forbiddenTACs_t const& ref_forbiddenTACs() const {return forbiddenTACs;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(forbiddenTACs);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(forbiddenTACs);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ forbiddenTACs.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ forbiddenTACs_t forbiddenTACs;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ForbiddenTAs ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ForbiddenTAs-Item
+*/
+
+struct ForbiddenTAs_elm : ForbiddenTAs_Item
+{
+ static constexpr const char* name() {return "ForbiddenTAs_elm";}
+ using parent_t = ForbiddenTAs_Item;
+
+};
+struct ForbiddenTAs : asn::sequenceof<ForbiddenTAs_elm>
+{
+ static constexpr const char* name() {return "ForbiddenTAs";}
+ using parent_t = asn::sequenceof<ForbiddenTAs_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
+
+};
+/*
+Fourframes ::= BIT STRING (SIZE (24))
+*/
+
+struct Fourframes : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<24>>;
+ static constexpr const char* name() {return "Fourframes";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+FreqBandIndicatorPriority ::= ENUMERATED {
+ not-broadcasted,
+ broadcasted,
+ ...
+}
+*/
+
+struct FreqBandIndicatorPriority : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "FreqBandIndicatorPriority";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ not_broadcasted
+ ,broadcasted
+ } index_t;
+
+};
+
+/*
+SupportedSULFreqBandItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SupportedSULFreqBandItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SupportedSULFreqBandItem ::= SEQUENCE {
+ freqBandIndicatorNr INTEGER (1..1024,...),
+ iE-Extensions ProtocolExtensionContainer { {SupportedSULFreqBandItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SupportedSULFreqBandItem : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "SupportedSULFreqBandItem";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct freqBandIndicatorNr_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
+ static constexpr const char* name() {return "freqBandIndicatorNr_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
+ freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(freqBandIndicatorNr);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(freqBandIndicatorNr);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ freqBandIndicatorNr.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ freqBandIndicatorNr_t freqBandIndicatorNr;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+FreqBandNrItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct FreqBandNrItem_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+FreqBandNrItem ::= SEQUENCE {
+ freqBandIndicatorNr INTEGER (1..1024,...),
+ supportedSULBandList SEQUENCE (SIZE(0..maxnoofNrCellBands)) OF SupportedSULFreqBandItem,
+ iE-Extensions ProtocolExtensionContainer { {FreqBandNrItem-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct FreqBandNrItem : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "FreqBandNrItem";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct freqBandIndicatorNr_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
+ static constexpr const char* name() {return "freqBandIndicatorNr_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
+ freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
+ struct supportedSULBandList_t_elm : SupportedSULFreqBandItem
+ {
+ static constexpr const char* name() {return "supportedSULBandList_t_elm";}
+ using parent_t = SupportedSULFreqBandItem;
+
+ };
+ struct supportedSULBandList_t : asn::sequenceof<supportedSULBandList_t_elm>
+ {
+ static constexpr const char* name() {return "supportedSULBandList_t";}
+ using parent_t = asn::sequenceof<supportedSULBandList_t_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxnoofNrCellBands >>;
+
+ };
+ supportedSULBandList_t& ref_supportedSULBandList() {return supportedSULBandList;}
+ supportedSULBandList_t const& ref_supportedSULBandList() const {return supportedSULBandList;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(freqBandIndicatorNr);
+ v(supportedSULBandList);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(freqBandIndicatorNr);
+ v(supportedSULBandList);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ freqBandIndicatorNr.clear();
+ supportedSULBandList.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ freqBandIndicatorNr_t freqBandIndicatorNr;
+ supportedSULBandList_t supportedSULBandList;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+GNB-ID ::= CHOICE {
+ gNB-ID BIT STRING (SIZE (22..32)),
+ ...
+}
+*/
+
+struct GNB_ID : asn::choice<1, 0, true>
+{
+ static constexpr const char* name() {return "GNB-ID";}
+ using parent_t = asn::choice<1, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 2;}
+ void set_unknown() { set_index(2); }
+ ~GNB_ID() {clear();}
+ struct gNB_ID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<22, 32>>;
+ static constexpr const char* name() {return "gNB_ID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<gNB_ID_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<gNB_ID_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<gNB_ID_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<gNB_ID_t>(1);
+
+ }
+ gNB_ID_t& select_gNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<gNB_ID_t>();} return var.as<gNB_ID_t>();}
+ gNB_ID_t const* get_gNB_ID() const { if(get_index() == 1) { return &var.as<gNB_ID_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(gNB_ID_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+GNBOverloadInformation ::= ENUMERATED {overloaded, not-overloaded, ...}
+*/
+
+struct GNBOverloadInformation : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "GNBOverloadInformation";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ overloaded
+ ,not_overloaded
+ } index_t;
+
+};
+
+/*
+GTP-TEI ::= OCTET STRING (SIZE (4))
+*/
+
+struct GTP_TEI : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<4>>;
+ static constexpr const char* name() {return "GTP-TEI";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+TransportLayerAddress ::= BIT STRING (SIZE(1..160, ...))
+*/
+
+struct TransportLayerAddress : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 160>>;
+ static constexpr const char* name() {return "TransportLayerAddress";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+GTPtunnelEndpoint-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct GTPtunnelEndpoint_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+GTPtunnelEndpoint ::= SEQUENCE {
+ transportLayerAddress TransportLayerAddress,
+ gTP-TEID GTP-TEI,
+ iE-Extensions ProtocolExtensionContainer { {GTPtunnelEndpoint-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GTPtunnelEndpoint : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "GTPtunnelEndpoint";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct transportLayerAddress_t : TransportLayerAddress
+ {
+ static constexpr const char* name() {return "transportLayerAddress_t";}
+ using parent_t = TransportLayerAddress;
+
+ };
+ transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
+ transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
+ struct gTP_TEID_t : GTP_TEI
+ {
+ static constexpr const char* name() {return "gTP_TEID_t";}
+ using parent_t = GTP_TEI;
+
+ };
+ gTP_TEID_t& ref_gTP_TEID() {return gTP_TEID;}
+ gTP_TEID_t const& ref_gTP_TEID() const {return gTP_TEID;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(transportLayerAddress);
+ v(gTP_TEID);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(transportLayerAddress);
+ v(gTP_TEID);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ transportLayerAddress.clear();
+ gTP_TEID.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ transportLayerAddress_t transportLayerAddress;
+ gTP_TEID_t gTP_TEID;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MME-Group-ID ::= OCTET STRING (SIZE (2))
+*/
+
+struct MME_Group_ID : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<2>>;
+ static constexpr const char* name() {return "MME-Group-ID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+GU-Group-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct GU_Group_ID_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+GU-Group-ID ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ mME-Group-ID MME-Group-ID,
+ iE-Extensions ProtocolExtensionContainer { {GU-Group-ID-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GU_Group_ID : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "GU-Group-ID";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct mME_Group_ID_t : MME_Group_ID
+ {
+ static constexpr const char* name() {return "mME_Group_ID_t";}
+ using parent_t = MME_Group_ID;
+
+ };
+ mME_Group_ID_t& ref_mME_Group_ID() {return mME_Group_ID;}
+ mME_Group_ID_t const& ref_mME_Group_ID() const {return mME_Group_ID;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GU_Group_ID_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GU_Group_ID_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(mME_Group_ID);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(mME_Group_ID);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ mME_Group_ID.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ mME_Group_ID_t mME_Group_ID;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+GUGroupIDList ::= SEQUENCE (SIZE (1..maxPools)) OF GU-Group-ID
+*/
+
+struct GUGroupIDList_elm : GU_Group_ID
+{
+ static constexpr const char* name() {return "GUGroupIDList_elm";}
+ using parent_t = GU_Group_ID;
+
+};
+struct GUGroupIDList : asn::sequenceof<GUGroupIDList_elm>
+{
+ static constexpr const char* name() {return "GUGroupIDList";}
+ using parent_t = asn::sequenceof<GUGroupIDList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxPools >>;
+
+};
+/*
+MME-Code ::= OCTET STRING (SIZE (1))
+*/
+
+struct MME_Code : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<1>>;
+ static constexpr const char* name() {return "MME-Code";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+GUMMEI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct GUMMEI_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+GUMMEI ::= SEQUENCE {
+
+ gU-Group-ID GU-Group-ID,
+ mME-Code MME-Code,
+ iE-Extensions ProtocolExtensionContainer { {GUMMEI-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GUMMEI : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "GUMMEI";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct gU_Group_ID_t : GU_Group_ID
+ {
+ static constexpr const char* name() {return "gU_Group_ID_t";}
+ using parent_t = GU_Group_ID;
+
+ };
+ gU_Group_ID_t& ref_gU_Group_ID() {return gU_Group_ID;}
+ gU_Group_ID_t const& ref_gU_Group_ID() const {return gU_Group_ID;}
+ struct mME_Code_t : MME_Code
+ {
+ static constexpr const char* name() {return "mME_Code_t";}
+ using parent_t = MME_Code;
+
+ };
+ mME_Code_t& ref_mME_Code() {return mME_Code;}
+ mME_Code_t const& ref_mME_Code() const {return mME_Code;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GUMMEI_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GUMMEI_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(gU_Group_ID);
+ v(mME_Code);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(gU_Group_ID);
+ v(mME_Code);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ gU_Group_ID.clear();
+ mME_Code.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ gU_Group_ID_t gU_Group_ID;
+ mME_Code_t mME_Code;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+GlobalENB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct GlobalENB_ID_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+GlobalENB-ID ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ eNB-ID ENB-ID,
+ iE-Extensions ProtocolExtensionContainer { {GlobalENB-ID-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GlobalENB_ID : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "GlobalENB-ID";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct eNB_ID_t : ENB_ID
+ {
+ static constexpr const char* name() {return "eNB_ID_t";}
+ using parent_t = ENB_ID;
+
+ };
+ eNB_ID_t& ref_eNB_ID() {return eNB_ID;}
+ eNB_ID_t const& ref_eNB_ID() const {return eNB_ID;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(eNB_ID);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(eNB_ID);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ eNB_ID.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ eNB_ID_t eNB_ID;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+GlobalGNB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct GlobalGNB_ID_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+GlobalGNB-ID ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ gNB-ID GNB-ID,
+ iE-Extensions ProtocolExtensionContainer { {GlobalGNB-ID-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct GlobalGNB_ID : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "GlobalGNB-ID";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct gNB_ID_t : GNB_ID
+ {
+ static constexpr const char* name() {return "gNB_ID_t";}
+ using parent_t = GNB_ID;
+
+ };
+ gNB_ID_t& ref_gNB_ID() {return gNB_ID;}
+ gNB_ID_t const& ref_gNB_ID() const {return gNB_ID;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(gNB_ID);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(gNB_ID);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ gNB_ID.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ gNB_ID_t gNB_ID;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+LoadIndicator ::= ENUMERATED {
+ lowLoad,
+ mediumLoad,
+ highLoad,
+ overLoad,
+ ...
+}
+*/
+
+struct LoadIndicator : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "LoadIndicator";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ lowLoad
+ ,mediumLoad
+ ,highLoad
+ ,overLoad
+ } index_t;
+
+};
+
+/*
+HWLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct HWLoadIndicator_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+HWLoadIndicator ::= SEQUENCE {
+ dLHWLoadIndicator LoadIndicator,
+ uLHWLoadIndicator LoadIndicator,
+ iE-Extensions ProtocolExtensionContainer { {HWLoadIndicator-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct HWLoadIndicator : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "HWLoadIndicator";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct dLHWLoadIndicator_t : LoadIndicator
+ {
+ static constexpr const char* name() {return "dLHWLoadIndicator_t";}
+ using parent_t = LoadIndicator;
+
+ };
+ dLHWLoadIndicator_t& ref_dLHWLoadIndicator() {return dLHWLoadIndicator;}
+ dLHWLoadIndicator_t const& ref_dLHWLoadIndicator() const {return dLHWLoadIndicator;}
+ struct uLHWLoadIndicator_t : LoadIndicator
+ {
+ static constexpr const char* name() {return "uLHWLoadIndicator_t";}
+ using parent_t = LoadIndicator;
+
+ };
+ uLHWLoadIndicator_t& ref_uLHWLoadIndicator() {return uLHWLoadIndicator;}
+ uLHWLoadIndicator_t const& ref_uLHWLoadIndicator() const {return uLHWLoadIndicator;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dLHWLoadIndicator);
+ v(uLHWLoadIndicator);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dLHWLoadIndicator);
+ v(uLHWLoadIndicator);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dLHWLoadIndicator.clear();
+ uLHWLoadIndicator.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dLHWLoadIndicator_t dLHWLoadIndicator;
+ uLHWLoadIndicator_t uLHWLoadIndicator;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+HandoverReportType ::= ENUMERATED {
+ hoTooEarly,
+ hoToWrongCell,
+ ...,
+ interRATpingpong
+}
+*/
+
+struct HandoverReportType : asn::enumerated<3, 1, true>
+{
+ static constexpr const char* name() {return "HandoverReportType";}
+ using parent_t = asn::enumerated<3, 1, true>;
+ typedef enum {
+ hoTooEarly
+ ,hoToWrongCell
+ ,interRATpingpong
+ } index_t;
+
+};
+
+/*
+NRrestrictioninEPSasSecondaryRAT ::= ENUMERATED {
+ nRrestrictedinEPSasSecondaryRAT,
+ ...
+}
+*/
+
+struct NRrestrictioninEPSasSecondaryRAT : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "NRrestrictioninEPSasSecondaryRAT";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ nRrestrictedinEPSasSecondaryRAT
+ } index_t;
+
+};
+
+/*
+NRrestrictionin5GS ::= ENUMERATED {
+ nRrestrictedin5GS,
+ ...
+}
+*/
+
+struct NRrestrictionin5GS : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "NRrestrictionin5GS";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ nRrestrictedin5GS
+ } index_t;
+
+};
+
+/*
+HandoverRestrictionList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-NRrestrictioninEPSasSecondaryRAT CRITICALITY ignore EXTENSION NRrestrictioninEPSasSecondaryRAT PRESENCE optional}|
+ { ID id-CNTypeRestrictions CRITICALITY ignore EXTENSION CNTypeRestrictions PRESENCE optional}|
+ { ID id-NRrestrictionin5GS CRITICALITY ignore EXTENSION NRrestrictionin5GS PRESENCE optional},
+ ...
+}
+*/
+
+struct HandoverRestrictionList_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_NRrestrictioninEPSasSecondaryRAT() { set(id_NRrestrictioninEPSasSecondaryRAT); type=1;}
+ void select_id_CNTypeRestrictions() { set(id_CNTypeRestrictions); type=2;}
+ void select_id_NRrestrictionin5GS() { set(id_NRrestrictionin5GS); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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_NRrestrictioninEPSasSecondaryRAT)) { type = 1; return true; }
+ else if(equal(id_CNTypeRestrictions)) { type = 2; return true; }
+ else if(equal(id_NRrestrictionin5GS)) { 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_NRrestrictioninEPSasSecondaryRAT);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_CNTypeRestrictions);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_NRrestrictionin5GS);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_NRrestrictioninEPSasSecondaryRAT() { set(ignore); type=1;}
+ void select_id_CNTypeRestrictions() { set(ignore); type=2;}
+ void select_id_NRrestrictionin5GS() { set(ignore); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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 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(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ NRrestrictioninEPSasSecondaryRAT& select_id_NRrestrictioninEPSasSecondaryRAT() { return set<NRrestrictioninEPSasSecondaryRAT>(1); }
+ NRrestrictioninEPSasSecondaryRAT const* get_id_NRrestrictioninEPSasSecondaryRAT() const { return get<NRrestrictioninEPSasSecondaryRAT>(1); }
+ CNTypeRestrictions& select_id_CNTypeRestrictions() { return set<CNTypeRestrictions>(2); }
+ CNTypeRestrictions const* get_id_CNTypeRestrictions() const { return get<CNTypeRestrictions>(2); }
+ NRrestrictionin5GS& select_id_NRrestrictionin5GS() { return set<NRrestrictionin5GS>(3); }
+ NRrestrictionin5GS const* get_id_NRrestrictionin5GS() const { return get<NRrestrictionin5GS>(3); }
+ bool is_unknown() const { return type == 4; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<NRrestrictioninEPSasSecondaryRAT>(); break;
+ case 2: var.destroy<CNTypeRestrictions>(); break;
+ case 3: var.destroy<NRrestrictionin5GS>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<NRrestrictioninEPSasSecondaryRAT>(1);
+ v.template operator()<CNTypeRestrictions>(2);
+ v.template operator()<NRrestrictionin5GS>(3);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_NRrestrictioninEPSasSecondaryRAT()); return true;
+ case 2: v(select_id_CNTypeRestrictions()); return true;
+ case 3: v(select_id_NRrestrictionin5GS()); 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<NRrestrictioninEPSasSecondaryRAT>()); return true;
+ case 2: v(var.as<CNTypeRestrictions>()); return true;
+ case 3: v(var.as<NRrestrictionin5GS>()); 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(CNTypeRestrictions)];
+ char dummy2[sizeof(NRrestrictionin5GS)];
+ char dummy3[sizeof(NRrestrictioninEPSasSecondaryRAT)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 4; }
+ void clear() {type = 0;}
+ void select_id_NRrestrictioninEPSasSecondaryRAT() { set(optional); type=1;}
+ void select_id_CNTypeRestrictions() { set(optional); type=2;}
+ void select_id_NRrestrictionin5GS() { set(optional); type=3;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+HandoverRestrictionList ::= SEQUENCE {
+ servingPLMN PLMN-Identity,
+ equivalentPLMNs EPLMNs OPTIONAL,
+ forbiddenTAs ForbiddenTAs OPTIONAL,
+ forbiddenLAs ForbiddenLAs OPTIONAL,
+ forbiddenInterRATs ForbiddenInterRATs OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {HandoverRestrictionList-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct HandoverRestrictionList : asn::sequence<6, 0, true, 5>
+{
+ static constexpr const char* name() {return "HandoverRestrictionList";}
+ using parent_t = asn::sequence<6, 0, true, 5>;
+ struct servingPLMN_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "servingPLMN_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ servingPLMN_t& ref_servingPLMN() {return servingPLMN;}
+ servingPLMN_t const& ref_servingPLMN() const {return servingPLMN;}
+ struct equivalentPLMNs_t : EPLMNs
+ {
+ static constexpr const char* name() {return "equivalentPLMNs_t";}
+ using parent_t = EPLMNs;
+ static constexpr bool optional = true;
+
+ };
+ equivalentPLMNs_t& set_equivalentPLMNs() { equivalentPLMNs.setpresent(true); return equivalentPLMNs;}
+ equivalentPLMNs_t const* get_equivalentPLMNs() const {return equivalentPLMNs.is_valid() ? &equivalentPLMNs : nullptr;}
+ struct forbiddenTAs_t : ForbiddenTAs
+ {
+ static constexpr const char* name() {return "forbiddenTAs_t";}
+ using parent_t = ForbiddenTAs;
+ static constexpr bool optional = true;
+
+ };
+ forbiddenTAs_t& set_forbiddenTAs() { forbiddenTAs.setpresent(true); return forbiddenTAs;}
+ forbiddenTAs_t const* get_forbiddenTAs() const {return forbiddenTAs.is_valid() ? &forbiddenTAs : nullptr;}
+ struct forbiddenLAs_t : ForbiddenLAs
+ {
+ static constexpr const char* name() {return "forbiddenLAs_t";}
+ using parent_t = ForbiddenLAs;
+ static constexpr bool optional = true;
+
+ };
+ forbiddenLAs_t& set_forbiddenLAs() { forbiddenLAs.setpresent(true); return forbiddenLAs;}
+ forbiddenLAs_t const* get_forbiddenLAs() const {return forbiddenLAs.is_valid() ? &forbiddenLAs : nullptr;}
+ struct forbiddenInterRATs_t : ForbiddenInterRATs
+ {
+ static constexpr const char* name() {return "forbiddenInterRATs_t";}
+ using parent_t = ForbiddenInterRATs;
+ static constexpr bool optional = true;
+
+ };
+ forbiddenInterRATs_t& set_forbiddenInterRATs() { forbiddenInterRATs.setpresent(true); return forbiddenInterRATs;}
+ forbiddenInterRATs_t const* get_forbiddenInterRATs() const {return forbiddenInterRATs.is_valid() ? &forbiddenInterRATs : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(servingPLMN);
+ v(equivalentPLMNs);
+ v(forbiddenTAs);
+ v(forbiddenLAs);
+ v(forbiddenInterRATs);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(servingPLMN);
+ v(equivalentPLMNs);
+ v(forbiddenTAs);
+ v(forbiddenLAs);
+ v(forbiddenInterRATs);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ servingPLMN.clear();
+ equivalentPLMNs.clear();
+ forbiddenTAs.clear();
+ forbiddenLAs.clear();
+ forbiddenInterRATs.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ servingPLMN_t servingPLMN;
+ equivalentPLMNs_t equivalentPLMNs;
+ forbiddenTAs_t forbiddenTAs;
+ forbiddenLAs_t forbiddenLAs;
+ forbiddenInterRATs_t forbiddenInterRATs;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+IntegrityProtectionAlgorithms ::= BIT STRING (SIZE (16, ...))
+*/
+
+struct IntegrityProtectionAlgorithms : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::one<16>>;
+ static constexpr const char* name() {return "IntegrityProtectionAlgorithms";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+InterfacesToTrace ::= BIT STRING (SIZE (8))
+*/
+
+struct InterfacesToTrace : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<8>>;
+ static constexpr const char* name() {return "InterfacesToTrace";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+InvokeIndication ::= ENUMERATED{
+ abs-information,
+ ...,
+ naics-information-start,
+ naics-information-stop
+}
+*/
+
+struct InvokeIndication : asn::enumerated<3, 2, true>
+{
+ static constexpr const char* name() {return "InvokeIndication";}
+ using parent_t = asn::enumerated<3, 2, true>;
+ typedef enum {
+ abs_information
+ ,naics_information_start
+ ,naics_information_stop
+ } index_t;
+
+};
+
+/*
+LCID ::= INTEGER(1..32, ...)
+*/
+
+struct LCID : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 32>>;
+ static constexpr const char* name() {return "LCID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+LHN-ID ::= OCTET STRING(SIZE (32..256))
+*/
+
+struct LHN_ID : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<32, 256>>;
+ static constexpr const char* name() {return "LHN-ID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+Time-UE-StayedInCell ::= INTEGER (0..4095)
+*/
+
+struct Time_UE_StayedInCell : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "Time-UE-StayedInCell";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+Time-UE-StayedInCell-EnhancedGranularity ::= INTEGER (0..40950)
+*/
+
+struct Time_UE_StayedInCell_EnhancedGranularity : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 40950>>;
+ static constexpr const char* name() {return "Time-UE-StayedInCell-EnhancedGranularity";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+LastVisitedEUTRANCellInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+-- Extension for Rel-11 to support enhanced granularity for time UE stayed in cell --
+ { ID id-Time-UE-StayedInCell-EnhancedGranularity CRITICALITY ignore EXTENSION Time-UE-StayedInCell-EnhancedGranularity PRESENCE optional}|
+ { ID id-HO-cause CRITICALITY ignore EXTENSION Cause PRESENCE optional},
+ ...
+}
+*/
+
+struct LastVisitedEUTRANCellInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(id_Time_UE_StayedInCell_EnhancedGranularity); type=1;}
+ void select_id_HO_cause() { set(id_HO_cause); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_Time_UE_StayedInCell_EnhancedGranularity)) { type = 1; return true; }
+ else if(equal(id_HO_cause)) { 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_Time_UE_StayedInCell_EnhancedGranularity);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_HO_cause);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(ignore); type=1;}
+ void select_id_HO_cause() { set(ignore); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { 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(ignore);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ Time_UE_StayedInCell_EnhancedGranularity& select_id_Time_UE_StayedInCell_EnhancedGranularity() { return set<Time_UE_StayedInCell_EnhancedGranularity>(1); }
+ Time_UE_StayedInCell_EnhancedGranularity const* get_id_Time_UE_StayedInCell_EnhancedGranularity() const { return get<Time_UE_StayedInCell_EnhancedGranularity>(1); }
+ Cause& select_id_HO_cause() { return set<Cause>(2); }
+ Cause const* get_id_HO_cause() const { return get<Cause>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<Time_UE_StayedInCell_EnhancedGranularity>(); break;
+ case 2: var.destroy<Cause>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<Time_UE_StayedInCell_EnhancedGranularity>(1);
+ v.template operator()<Cause>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_Time_UE_StayedInCell_EnhancedGranularity()); return true;
+ case 2: v(select_id_HO_cause()); 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<Time_UE_StayedInCell_EnhancedGranularity>()); return true;
+ case 2: v(var.as<Cause>()); 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(Cause)];
+ char dummy2[sizeof(Time_UE_StayedInCell_EnhancedGranularity)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(optional); type=1;}
+ void select_id_HO_cause() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+LastVisitedEUTRANCellInformation ::= SEQUENCE {
+ global-Cell-ID ECGI,
+ cellType CellType,
+ time-UE-StayedInCell Time-UE-StayedInCell,
+ iE-Extensions ProtocolExtensionContainer { {LastVisitedEUTRANCellInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct LastVisitedEUTRANCellInformation : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "LastVisitedEUTRANCellInformation";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct global_Cell_ID_t : ECGI
+ {
+ static constexpr const char* name() {return "global_Cell_ID_t";}
+ using parent_t = ECGI;
+
+ };
+ global_Cell_ID_t& ref_global_Cell_ID() {return global_Cell_ID;}
+ global_Cell_ID_t const& ref_global_Cell_ID() const {return global_Cell_ID;}
+ struct cellType_t : CellType
+ {
+ static constexpr const char* name() {return "cellType_t";}
+ using parent_t = CellType;
+
+ };
+ cellType_t& ref_cellType() {return cellType;}
+ cellType_t const& ref_cellType() const {return cellType;}
+ struct time_UE_StayedInCell_t : Time_UE_StayedInCell
+ {
+ static constexpr const char* name() {return "time_UE_StayedInCell_t";}
+ using parent_t = Time_UE_StayedInCell;
+
+ };
+ time_UE_StayedInCell_t& ref_time_UE_StayedInCell() {return time_UE_StayedInCell;}
+ time_UE_StayedInCell_t const& ref_time_UE_StayedInCell() const {return time_UE_StayedInCell;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(global_Cell_ID);
+ v(cellType);
+ v(time_UE_StayedInCell);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(global_Cell_ID);
+ v(cellType);
+ v(time_UE_StayedInCell);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ global_Cell_ID.clear();
+ cellType.clear();
+ time_UE_StayedInCell.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ global_Cell_ID_t global_Cell_ID;
+ cellType_t cellType;
+ time_UE_StayedInCell_t time_UE_StayedInCell;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+LastVisitedUTRANCellInformation ::= OCTET STRING
+*/
+
+struct LastVisitedUTRANCellInformation : asn::ostring<>
+{
+ static constexpr const char* name() {return "LastVisitedUTRANCellInformation";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+LastVisitedGERANCellInformation ::= CHOICE {
+ undefined NULL,
+ ...
+}
+*/
+
+struct LastVisitedGERANCellInformation : asn::choice<1, 0, true>
+{
+ static constexpr const char* name() {return "LastVisitedGERANCellInformation";}
+ using parent_t = asn::choice<1, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 2;}
+ void set_unknown() { set_index(2); }
+ ~LastVisitedGERANCellInformation() {clear();}
+ struct undefined_t : asn::nulltype
+ {
+ static constexpr const char* name() {return "undefined_t";}
+ using parent_t = asn::nulltype;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<undefined_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<undefined_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<undefined_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<undefined_t>(1);
+
+ }
+ undefined_t& select_undefined() { if(get_index() != 1) { clear(); set_index(1); return var.build<undefined_t>();} return var.as<undefined_t>();}
+ undefined_t const* get_undefined() const { if(get_index() == 1) { return &var.as<undefined_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(undefined_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+LastVisitedNGRANCellInformation ::= OCTET STRING
+*/
+
+struct LastVisitedNGRANCellInformation : asn::ostring<>
+{
+ static constexpr const char* name() {return "LastVisitedNGRANCellInformation";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+LastVisitedCell-Item ::= CHOICE {
+ e-UTRAN-Cell LastVisitedEUTRANCellInformation,
+ uTRAN-Cell LastVisitedUTRANCellInformation,
+ gERAN-Cell LastVisitedGERANCellInformation,
+ ...,
+ nG-RAN-Cell LastVisitedNGRANCellInformation
+}
+*/
+
+struct LastVisitedCell_Item : asn::choice<4, 1, true>
+{
+ static constexpr const char* name() {return "LastVisitedCell-Item";}
+ using parent_t = asn::choice<4, 1, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 5;}
+ void set_unknown() { set_index(5); }
+ ~LastVisitedCell_Item() {clear();}
+ struct e_UTRAN_Cell_t : LastVisitedEUTRANCellInformation
+ {
+ static constexpr const char* name() {return "e_UTRAN_Cell_t";}
+ using parent_t = LastVisitedEUTRANCellInformation;
+
+ };
+ struct uTRAN_Cell_t : LastVisitedUTRANCellInformation
+ {
+ static constexpr const char* name() {return "uTRAN_Cell_t";}
+ using parent_t = LastVisitedUTRANCellInformation;
+
+ };
+ struct gERAN_Cell_t : LastVisitedGERANCellInformation
+ {
+ static constexpr const char* name() {return "gERAN_Cell_t";}
+ using parent_t = LastVisitedGERANCellInformation;
+
+ };
+ struct nG_RAN_Cell_t : LastVisitedNGRANCellInformation
+ {
+ static constexpr const char* name() {return "nG_RAN_Cell_t";}
+ using parent_t = LastVisitedNGRANCellInformation;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<e_UTRAN_Cell_t>(); break;
+ case 2: var.destroy<uTRAN_Cell_t>(); break;
+ case 3: var.destroy<gERAN_Cell_t>(); break;
+ case 4: var.destroy<nG_RAN_Cell_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<e_UTRAN_Cell_t>());
+ case 2: set_index(2); return v(var.build<uTRAN_Cell_t>());
+ case 3: set_index(3); return v(var.build<gERAN_Cell_t>());
+ case 4: set_index(4); return v(var.build<nG_RAN_Cell_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<e_UTRAN_Cell_t>());
+ case 2: return v(var.as<uTRAN_Cell_t>());
+ case 3: return v(var.as<gERAN_Cell_t>());
+ case 4: return v(var.as<nG_RAN_Cell_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<e_UTRAN_Cell_t>(1);
+ v.template operator()<uTRAN_Cell_t>(2);
+ v.template operator()<gERAN_Cell_t>(3);
+ v.template operator()<nG_RAN_Cell_t>(4);
+
+ }
+ e_UTRAN_Cell_t& select_e_UTRAN_Cell() { if(get_index() != 1) { clear(); set_index(1); return var.build<e_UTRAN_Cell_t>();} return var.as<e_UTRAN_Cell_t>();}
+ e_UTRAN_Cell_t const* get_e_UTRAN_Cell() const { if(get_index() == 1) { return &var.as<e_UTRAN_Cell_t>();} return nullptr; }
+ uTRAN_Cell_t& select_uTRAN_Cell() { if(get_index() != 2) { clear(); set_index(2); return var.build<uTRAN_Cell_t>();} return var.as<uTRAN_Cell_t>();}
+ uTRAN_Cell_t const* get_uTRAN_Cell() const { if(get_index() == 2) { return &var.as<uTRAN_Cell_t>();} return nullptr; }
+ gERAN_Cell_t& select_gERAN_Cell() { if(get_index() != 3) { clear(); set_index(3); return var.build<gERAN_Cell_t>();} return var.as<gERAN_Cell_t>();}
+ gERAN_Cell_t const* get_gERAN_Cell() const { if(get_index() == 3) { return &var.as<gERAN_Cell_t>();} return nullptr; }
+ nG_RAN_Cell_t& select_nG_RAN_Cell() { if(get_index() != 4) { clear(); set_index(4); return var.build<nG_RAN_Cell_t>();} return var.as<nG_RAN_Cell_t>();}
+ nG_RAN_Cell_t const* get_nG_RAN_Cell() const { if(get_index() == 4) { return &var.as<nG_RAN_Cell_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(e_UTRAN_Cell_t)];
+ char dummy2[sizeof(uTRAN_Cell_t)];
+ char dummy3[sizeof(gERAN_Cell_t)];
+ char dummy4[sizeof(nG_RAN_Cell_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+Links-to-log ::= ENUMERATED {uplink, downlink, both-uplink-and-downlink, ...}
+*/
+
+struct Links_to_log : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "Links-to-log";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ uplink
+ ,downlink
+ ,both_uplink_and_downlink
+ } index_t;
+
+};
+
+/*
+ReportArea ::= ENUMERATED{
+ ecgi,
+ ...
+}
+*/
+
+struct ReportArea : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "ReportArea";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ ecgi
+ } index_t;
+
+};
+
+/*
+LocationReportingInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::={
+ ...
+}
+*/
+
+struct LocationReportingInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+LocationReportingInformation ::= SEQUENCE {
+ eventType EventType,
+ reportArea ReportArea,
+ iE-Extensions ProtocolExtensionContainer { {LocationReportingInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct LocationReportingInformation : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "LocationReportingInformation";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct eventType_t : EventType
+ {
+ static constexpr const char* name() {return "eventType_t";}
+ using parent_t = EventType;
+
+ };
+ eventType_t& ref_eventType() {return eventType;}
+ eventType_t const& ref_eventType() const {return eventType;}
+ struct reportArea_t : ReportArea
+ {
+ static constexpr const char* name() {return "reportArea_t";}
+ using parent_t = ReportArea;
+
+ };
+ reportArea_t& ref_reportArea() {return reportArea;}
+ reportArea_t const& ref_reportArea() const {return reportArea;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eventType);
+ v(reportArea);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eventType);
+ v(reportArea);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ eventType.clear();
+ reportArea.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ eventType_t eventType;
+ reportArea_t reportArea;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ReportIntervalMDT ::= ENUMERATED {ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, min1, min6, min12, min30, min60}
+*/
+
+struct ReportIntervalMDT : asn::enumerated<13, 0, false>
+{
+ static constexpr const char* name() {return "ReportIntervalMDT";}
+ using parent_t = asn::enumerated<13, 0, false>;
+ typedef enum {
+ ms120
+ ,ms240
+ ,ms480
+ ,ms640
+ ,ms1024
+ ,ms2048
+ ,ms5120
+ ,ms10240
+ ,min1
+ ,min6
+ ,min12
+ ,min30
+ ,min60
+ } index_t;
+
+};
+
+/*
+ReportAmountMDT ::= ENUMERATED{r1, r2, r4, r8, r16, r32, r64, rinfinity}
+*/
+
+struct ReportAmountMDT : asn::enumerated<8, 0, false>
+{
+ static constexpr const char* name() {return "ReportAmountMDT";}
+ using parent_t = asn::enumerated<8, 0, false>;
+ typedef enum {
+ r1
+ ,r2
+ ,r4
+ ,r8
+ ,r16
+ ,r32
+ ,r64
+ ,rinfinity
+ } index_t;
+
+};
+
+/*
+M1PeriodicReporting-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M1PeriodicReporting_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M1PeriodicReporting ::= SEQUENCE {
+ reportInterval ReportIntervalMDT,
+ reportAmount ReportAmountMDT,
+ iE-Extensions ProtocolExtensionContainer { {M1PeriodicReporting-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M1PeriodicReporting : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "M1PeriodicReporting";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct reportInterval_t : ReportIntervalMDT
+ {
+ static constexpr const char* name() {return "reportInterval_t";}
+ using parent_t = ReportIntervalMDT;
+
+ };
+ reportInterval_t& ref_reportInterval() {return reportInterval;}
+ reportInterval_t const& ref_reportInterval() const {return reportInterval;}
+ struct reportAmount_t : ReportAmountMDT
+ {
+ static constexpr const char* name() {return "reportAmount_t";}
+ using parent_t = ReportAmountMDT;
+
+ };
+ reportAmount_t& ref_reportAmount() {return reportAmount;}
+ reportAmount_t const& ref_reportAmount() const {return reportAmount;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(reportInterval);
+ v(reportAmount);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(reportInterval);
+ v(reportAmount);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ reportInterval.clear();
+ reportAmount.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ reportInterval_t reportInterval;
+ reportAmount_t reportAmount;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M1ReportingTrigger::= ENUMERATED{
+ periodic,
+ a2eventtriggered,
+ ...,
+ a2eventtriggered-periodic
+}
+*/
+
+struct M1ReportingTrigger : asn::enumerated<3, 1, true>
+{
+ static constexpr const char* name() {return "M1ReportingTrigger";}
+ using parent_t = asn::enumerated<3, 1, true>;
+ typedef enum {
+ periodic
+ ,a2eventtriggered
+ ,a2eventtriggered_periodic
+ } index_t;
+
+};
+
+/*
+Threshold-RSRP ::= INTEGER(0..97)
+*/
+
+struct Threshold_RSRP : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 97>>;
+ static constexpr const char* name() {return "Threshold-RSRP";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+Threshold-RSRQ ::= INTEGER(0..34)
+*/
+
+struct Threshold_RSRQ : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 34>>;
+ static constexpr const char* name() {return "Threshold-RSRQ";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+MeasurementThresholdA2 ::= CHOICE {
+ threshold-RSRP Threshold-RSRP,
+ threshold-RSRQ Threshold-RSRQ,
+ ...
+}
+*/
+
+struct MeasurementThresholdA2 : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "MeasurementThresholdA2";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~MeasurementThresholdA2() {clear();}
+ struct threshold_RSRP_t : Threshold_RSRP
+ {
+ static constexpr const char* name() {return "threshold_RSRP_t";}
+ using parent_t = Threshold_RSRP;
+
+ };
+ struct threshold_RSRQ_t : Threshold_RSRQ
+ {
+ static constexpr const char* name() {return "threshold_RSRQ_t";}
+ using parent_t = Threshold_RSRQ;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<threshold_RSRP_t>(); break;
+ case 2: var.destroy<threshold_RSRQ_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<threshold_RSRP_t>());
+ case 2: set_index(2); return v(var.build<threshold_RSRQ_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<threshold_RSRP_t>());
+ case 2: return v(var.as<threshold_RSRQ_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<threshold_RSRP_t>(1);
+ v.template operator()<threshold_RSRQ_t>(2);
+
+ }
+ threshold_RSRP_t& select_threshold_RSRP() { if(get_index() != 1) { clear(); set_index(1); return var.build<threshold_RSRP_t>();} return var.as<threshold_RSRP_t>();}
+ threshold_RSRP_t const* get_threshold_RSRP() const { if(get_index() == 1) { return &var.as<threshold_RSRP_t>();} return nullptr; }
+ threshold_RSRQ_t& select_threshold_RSRQ() { if(get_index() != 2) { clear(); set_index(2); return var.build<threshold_RSRQ_t>();} return var.as<threshold_RSRQ_t>();}
+ threshold_RSRQ_t const* get_threshold_RSRQ() const { if(get_index() == 2) { return &var.as<threshold_RSRQ_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(threshold_RSRP_t)];
+ char dummy2[sizeof(threshold_RSRQ_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+M1ThresholdEventA2-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M1ThresholdEventA2_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M1ThresholdEventA2 ::= SEQUENCE {
+ measurementThreshold MeasurementThresholdA2,
+ iE-Extensions ProtocolExtensionContainer { {M1ThresholdEventA2-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M1ThresholdEventA2 : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "M1ThresholdEventA2";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct measurementThreshold_t : MeasurementThresholdA2
+ {
+ static constexpr const char* name() {return "measurementThreshold_t";}
+ using parent_t = MeasurementThresholdA2;
+
+ };
+ measurementThreshold_t& ref_measurementThreshold() {return measurementThreshold;}
+ measurementThreshold_t const& ref_measurementThreshold() const {return measurementThreshold;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(measurementThreshold);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(measurementThreshold);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ measurementThreshold.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ measurementThreshold_t measurementThreshold;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M3period ::= ENUMERATED {ms100, ms1000, ms10000, ... }
+*/
+
+struct M3period : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "M3period";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ ms100
+ ,ms1000
+ ,ms10000
+ } index_t;
+
+};
+
+/*
+M3Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M3Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M3Configuration ::= SEQUENCE {
+ m3period M3period,
+ iE-Extensions ProtocolExtensionContainer { {M3Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M3Configuration : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "M3Configuration";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct m3period_t : M3period
+ {
+ static constexpr const char* name() {return "m3period_t";}
+ using parent_t = M3period;
+
+ };
+ m3period_t& ref_m3period() {return m3period;}
+ m3period_t const& ref_m3period() const {return m3period;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M3Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M3Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(m3period);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(m3period);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ m3period.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ m3period_t m3period;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M4period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
+*/
+
+struct M4period : asn::enumerated<5, 0, true>
+{
+ static constexpr const char* name() {return "M4period";}
+ using parent_t = asn::enumerated<5, 0, true>;
+ typedef enum {
+ ms1024
+ ,ms2048
+ ,ms5120
+ ,ms10240
+ ,min1
+ } index_t;
+
+};
+
+/*
+M4Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M4Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M4Configuration ::= SEQUENCE {
+ m4period M4period,
+ m4-links-to-log Links-to-log,
+ iE-Extensions ProtocolExtensionContainer { {M4Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M4Configuration : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "M4Configuration";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct m4period_t : M4period
+ {
+ static constexpr const char* name() {return "m4period_t";}
+ using parent_t = M4period;
+
+ };
+ m4period_t& ref_m4period() {return m4period;}
+ m4period_t const& ref_m4period() const {return m4period;}
+ struct m4_links_to_log_t : Links_to_log
+ {
+ static constexpr const char* name() {return "m4_links_to_log_t";}
+ using parent_t = Links_to_log;
+
+ };
+ m4_links_to_log_t& ref_m4_links_to_log() {return m4_links_to_log;}
+ m4_links_to_log_t const& ref_m4_links_to_log() const {return m4_links_to_log;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M4Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M4Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(m4period);
+ v(m4_links_to_log);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(m4period);
+ v(m4_links_to_log);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ m4period.clear();
+ m4_links_to_log.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ m4period_t m4period;
+ m4_links_to_log_t m4_links_to_log;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M5period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
+*/
+
+struct M5period : asn::enumerated<5, 0, true>
+{
+ static constexpr const char* name() {return "M5period";}
+ using parent_t = asn::enumerated<5, 0, true>;
+ typedef enum {
+ ms1024
+ ,ms2048
+ ,ms5120
+ ,ms10240
+ ,min1
+ } index_t;
+
+};
+
+/*
+M5Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M5Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M5Configuration ::= SEQUENCE {
+ m5period M5period,
+ m5-links-to-log Links-to-log,
+ iE-Extensions ProtocolExtensionContainer { {M5Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M5Configuration : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "M5Configuration";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct m5period_t : M5period
+ {
+ static constexpr const char* name() {return "m5period_t";}
+ using parent_t = M5period;
+
+ };
+ m5period_t& ref_m5period() {return m5period;}
+ m5period_t const& ref_m5period() const {return m5period;}
+ struct m5_links_to_log_t : Links_to_log
+ {
+ static constexpr const char* name() {return "m5_links_to_log_t";}
+ using parent_t = Links_to_log;
+
+ };
+ m5_links_to_log_t& ref_m5_links_to_log() {return m5_links_to_log;}
+ m5_links_to_log_t const& ref_m5_links_to_log() const {return m5_links_to_log;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M5Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M5Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(m5period);
+ v(m5_links_to_log);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(m5period);
+ v(m5_links_to_log);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ m5period.clear();
+ m5_links_to_log.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ m5period_t m5period;
+ m5_links_to_log_t m5_links_to_log;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M6report-interval ::= ENUMERATED { ms1024, ms2048, ms5120, ms10240, ... }
+*/
+
+struct M6report_interval : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "M6report-interval";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ ms1024
+ ,ms2048
+ ,ms5120
+ ,ms10240
+ } index_t;
+
+};
+
+/*
+M6delay-threshold ::= ENUMERATED { ms30, ms40, ms50, ms60, ms70, ms80, ms90, ms100, ms150, ms300, ms500, ms750, ... }
+*/
+
+struct M6delay_threshold : asn::enumerated<12, 0, true>
+{
+ static constexpr const char* name() {return "M6delay-threshold";}
+ using parent_t = asn::enumerated<12, 0, true>;
+ typedef enum {
+ ms30
+ ,ms40
+ ,ms50
+ ,ms60
+ ,ms70
+ ,ms80
+ ,ms90
+ ,ms100
+ ,ms150
+ ,ms300
+ ,ms500
+ ,ms750
+ } index_t;
+
+};
+
+/*
+M6Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M6Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M6Configuration ::= SEQUENCE {
+ m6report-interval M6report-interval,
+ m6delay-threshold M6delay-threshold OPTIONAL,
+-- This IE shall be present if the M6 Links to log IE is set to “uplink” or to “both-uplink-and-downlink” --
+ m6-links-to-log Links-to-log,
+ iE-Extensions ProtocolExtensionContainer { {M6Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M6Configuration : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "M6Configuration";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct m6report_interval_t : M6report_interval
+ {
+ static constexpr const char* name() {return "m6report_interval_t";}
+ using parent_t = M6report_interval;
+
+ };
+ m6report_interval_t& ref_m6report_interval() {return m6report_interval;}
+ m6report_interval_t const& ref_m6report_interval() const {return m6report_interval;}
+ struct m6delay_threshold_t : M6delay_threshold
+ {
+ static constexpr const char* name() {return "m6delay_threshold_t";}
+ using parent_t = M6delay_threshold;
+ static constexpr bool optional = true;
+
+ };
+ m6delay_threshold_t& set_m6delay_threshold() { m6delay_threshold.setpresent(true); return m6delay_threshold;}
+ m6delay_threshold_t const* get_m6delay_threshold() const {return m6delay_threshold.is_valid() ? &m6delay_threshold : nullptr;}
+ struct m6_links_to_log_t : Links_to_log
+ {
+ static constexpr const char* name() {return "m6_links_to_log_t";}
+ using parent_t = Links_to_log;
+
+ };
+ m6_links_to_log_t& ref_m6_links_to_log() {return m6_links_to_log;}
+ m6_links_to_log_t const& ref_m6_links_to_log() const {return m6_links_to_log;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M6Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M6Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(m6report_interval);
+ v(m6delay_threshold);
+ v(m6_links_to_log);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(m6report_interval);
+ v(m6delay_threshold);
+ v(m6_links_to_log);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ m6report_interval.clear();
+ m6delay_threshold.clear();
+ m6_links_to_log.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ m6report_interval_t m6report_interval;
+ m6delay_threshold_t m6delay_threshold;
+ m6_links_to_log_t m6_links_to_log;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+M7period ::= INTEGER(1..60, ...)
+*/
+
+struct M7period : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 60>>;
+ static constexpr const char* name() {return "M7period";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+M7Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct M7Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+M7Configuration ::= SEQUENCE {
+ m7period M7period,
+ m7-links-to-log Links-to-log,
+ iE-Extensions ProtocolExtensionContainer { {M7Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct M7Configuration : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "M7Configuration";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct m7period_t : M7period
+ {
+ static constexpr const char* name() {return "m7period_t";}
+ using parent_t = M7period;
+
+ };
+ m7period_t& ref_m7period() {return m7period;}
+ m7period_t const& ref_m7period() const {return m7period;}
+ struct m7_links_to_log_t : Links_to_log
+ {
+ static constexpr const char* name() {return "m7_links_to_log_t";}
+ using parent_t = Links_to_log;
+
+ };
+ m7_links_to_log_t& ref_m7_links_to_log() {return m7_links_to_log;}
+ m7_links_to_log_t const& ref_m7_links_to_log() const {return m7_links_to_log;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<M7Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<M7Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(m7period);
+ v(m7_links_to_log);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(m7period);
+ v(m7_links_to_log);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ m7period.clear();
+ m7_links_to_log.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ m7period_t m7period;
+ m7_links_to_log_t m7_links_to_log;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MBMS-Service-Area-Identity ::= OCTET STRING (SIZE (2))
+*/
+
+struct MBMS_Service_Area_Identity : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<2>>;
+ static constexpr const char* name() {return "MBMS-Service-Area-Identity";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+MBMS-Service-Area-Identity-List ::= SEQUENCE (SIZE(1.. maxnoofMBMSServiceAreaIdentities)) OF MBMS-Service-Area-Identity
+*/
+
+struct MBMS_Service_Area_Identity_List_elm : MBMS_Service_Area_Identity
+{
+ static constexpr const char* name() {return "MBMS_Service_Area_Identity_List_elm";}
+ using parent_t = MBMS_Service_Area_Identity;
+
+};
+struct MBMS_Service_Area_Identity_List : asn::sequenceof<MBMS_Service_Area_Identity_List_elm>
+{
+ static constexpr const char* name() {return "MBMS-Service-Area-Identity-List";}
+ using parent_t = asn::sequenceof<MBMS_Service_Area_Identity_List_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofMBMSServiceAreaIdentities >>;
+
+};
+/*
+RadioframeAllocationPeriod ::= ENUMERATED{
+ n1,
+ n2,
+ n4,
+ n8,
+ n16,
+ n32,
+ ...
+}
+*/
+
+struct RadioframeAllocationPeriod : asn::enumerated<6, 0, true>
+{
+ static constexpr const char* name() {return "RadioframeAllocationPeriod";}
+ using parent_t = asn::enumerated<6, 0, true>;
+ typedef enum {
+ n1
+ ,n2
+ ,n4
+ ,n8
+ ,n16
+ ,n32
+ } index_t;
+
+};
+
+/*
+RadioframeAllocationOffset ::= INTEGER (0..7, ...)
+*/
+
+struct RadioframeAllocationOffset : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<0, 7>>;
+ static constexpr const char* name() {return "RadioframeAllocationOffset";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+Oneframe ::= BIT STRING (SIZE (6))
+*/
+
+struct Oneframe : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<6>>;
+ static constexpr const char* name() {return "Oneframe";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+SubframeAllocation ::= CHOICE {
+ oneframe Oneframe,
+ fourframes Fourframes,
+ ...
+}
+*/
+
+struct SubframeAllocation : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "SubframeAllocation";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~SubframeAllocation() {clear();}
+ struct oneframe_t : Oneframe
+ {
+ static constexpr const char* name() {return "oneframe_t";}
+ using parent_t = Oneframe;
+
+ };
+ struct fourframes_t : Fourframes
+ {
+ static constexpr const char* name() {return "fourframes_t";}
+ using parent_t = Fourframes;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<oneframe_t>(); break;
+ case 2: var.destroy<fourframes_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<oneframe_t>());
+ case 2: set_index(2); return v(var.build<fourframes_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<oneframe_t>());
+ case 2: return v(var.as<fourframes_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<oneframe_t>(1);
+ v.template operator()<fourframes_t>(2);
+
+ }
+ oneframe_t& select_oneframe() { if(get_index() != 1) { clear(); set_index(1); return var.build<oneframe_t>();} return var.as<oneframe_t>();}
+ oneframe_t const* get_oneframe() const { if(get_index() == 1) { return &var.as<oneframe_t>();} return nullptr; }
+ fourframes_t& select_fourframes() { if(get_index() != 2) { clear(); set_index(2); return var.build<fourframes_t>();} return var.as<fourframes_t>();}
+ fourframes_t const* get_fourframes() const { if(get_index() == 2) { return &var.as<fourframes_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(oneframe_t)];
+ char dummy2[sizeof(fourframes_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+MBSFN-Subframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct MBSFN_Subframe_Info_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+MBSFN-Subframe-Info ::= SEQUENCE {
+ radioframeAllocationPeriod RadioframeAllocationPeriod,
+ radioframeAllocationOffset RadioframeAllocationOffset,
+ subframeAllocation SubframeAllocation,
+ iE-Extensions ProtocolExtensionContainer { {MBSFN-Subframe-Info-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct MBSFN_Subframe_Info : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "MBSFN-Subframe-Info";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct radioframeAllocationPeriod_t : RadioframeAllocationPeriod
+ {
+ static constexpr const char* name() {return "radioframeAllocationPeriod_t";}
+ using parent_t = RadioframeAllocationPeriod;
+
+ };
+ radioframeAllocationPeriod_t& ref_radioframeAllocationPeriod() {return radioframeAllocationPeriod;}
+ radioframeAllocationPeriod_t const& ref_radioframeAllocationPeriod() const {return radioframeAllocationPeriod;}
+ struct radioframeAllocationOffset_t : RadioframeAllocationOffset
+ {
+ static constexpr const char* name() {return "radioframeAllocationOffset_t";}
+ using parent_t = RadioframeAllocationOffset;
+
+ };
+ radioframeAllocationOffset_t& ref_radioframeAllocationOffset() {return radioframeAllocationOffset;}
+ radioframeAllocationOffset_t const& ref_radioframeAllocationOffset() const {return radioframeAllocationOffset;}
+ struct subframeAllocation_t : SubframeAllocation
+ {
+ static constexpr const char* name() {return "subframeAllocation_t";}
+ using parent_t = SubframeAllocation;
+
+ };
+ subframeAllocation_t& ref_subframeAllocation() {return subframeAllocation;}
+ subframeAllocation_t const& ref_subframeAllocation() const {return subframeAllocation;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(radioframeAllocationPeriod);
+ v(radioframeAllocationOffset);
+ v(subframeAllocation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(radioframeAllocationPeriod);
+ v(radioframeAllocationOffset);
+ v(subframeAllocation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ radioframeAllocationPeriod.clear();
+ radioframeAllocationOffset.clear();
+ subframeAllocation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ radioframeAllocationPeriod_t radioframeAllocationPeriod;
+ radioframeAllocationOffset_t radioframeAllocationOffset;
+ subframeAllocation_t subframeAllocation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MBSFN-Subframe-Infolist::= SEQUENCE (SIZE(1.. maxnoofMBSFN)) OF MBSFN-Subframe-Info
+*/
+
+struct MBSFN_Subframe_Infolist_elm : MBSFN_Subframe_Info
+{
+ static constexpr const char* name() {return "MBSFN_Subframe_Infolist_elm";}
+ using parent_t = MBSFN_Subframe_Info;
+
+};
+struct MBSFN_Subframe_Infolist : asn::sequenceof<MBSFN_Subframe_Infolist_elm>
+{
+ static constexpr const char* name() {return "MBSFN-Subframe-Infolist";}
+ using parent_t = asn::sequenceof<MBSFN_Subframe_Infolist_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofMBSFN >>;
+
+};
+/*
+MDT-Activation ::= ENUMERATED {
+ immediate-MDT-only,
+ immediate-MDT-and-Trace,
+ ...
+}
+*/
+
+struct MDT_Activation : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "MDT-Activation";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ immediate_MDT_only
+ ,immediate_MDT_and_Trace
+ } index_t;
+
+};
+
+/*
+MeasurementsToActivate::= BIT STRING (SIZE (8))
+*/
+
+struct MeasurementsToActivate : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<8>>;
+ static constexpr const char* name() {return "MeasurementsToActivate";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+MDT-Location-Info ::= BIT STRING (SIZE (8))
+*/
+
+struct MDT_Location_Info : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<8>>;
+ static constexpr const char* name() {return "MDT-Location-Info";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+MDTPLMNList ::= SEQUENCE (SIZE(1..maxnoofMDTPLMNs)) OF PLMN-Identity
+*/
+
+struct MDTPLMNList_elm : PLMN_Identity
+{
+ static constexpr const char* name() {return "MDTPLMNList_elm";}
+ using parent_t = PLMN_Identity;
+
+};
+struct MDTPLMNList : asn::sequenceof<MDTPLMNList_elm>
+{
+ static constexpr const char* name() {return "MDTPLMNList";}
+ using parent_t = asn::sequenceof<MDTPLMNList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofMDTPLMNs >>;
+
+};
+/*
+WLANMeasConfig::= ENUMERATED {setup,...}
+*/
+
+struct WLANMeasConfig : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "WLANMeasConfig";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ setup
+ } index_t;
+
+};
+
+/*
+WLANName ::= OCTET STRING (SIZE (1..32))
+*/
+
+struct WLANName : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 32>>;
+ static constexpr const char* name() {return "WLANName";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+WLANMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofWLANName)) OF WLANName
+*/
+
+struct WLANMeasConfigNameList_elm : WLANName
+{
+ static constexpr const char* name() {return "WLANMeasConfigNameList_elm";}
+ using parent_t = WLANName;
+
+};
+struct WLANMeasConfigNameList : asn::sequenceof<WLANMeasConfigNameList_elm>
+{
+ static constexpr const char* name() {return "WLANMeasConfigNameList";}
+ using parent_t = asn::sequenceof<WLANMeasConfigNameList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofWLANName >>;
+
+};
+/*
+WLANMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct WLANMeasurementConfiguration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+WLANMeasurementConfiguration ::= SEQUENCE {
+ wlanMeasConfig WLANMeasConfig,
+ wlanMeasConfigNameList WLANMeasConfigNameList OPTIONAL,
+ wlan-rssi ENUMERATED {true, ...} OPTIONAL,
+ wlan-rtt ENUMERATED {true, ...} OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {WLANMeasurementConfiguration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct WLANMeasurementConfiguration : asn::sequence<5, 0, true, 4>
+{
+ static constexpr const char* name() {return "WLANMeasurementConfiguration";}
+ using parent_t = asn::sequence<5, 0, true, 4>;
+ struct wlanMeasConfig_t : WLANMeasConfig
+ {
+ static constexpr const char* name() {return "wlanMeasConfig_t";}
+ using parent_t = WLANMeasConfig;
+
+ };
+ wlanMeasConfig_t& ref_wlanMeasConfig() {return wlanMeasConfig;}
+ wlanMeasConfig_t const& ref_wlanMeasConfig() const {return wlanMeasConfig;}
+ struct wlanMeasConfigNameList_t : WLANMeasConfigNameList
+ {
+ static constexpr const char* name() {return "wlanMeasConfigNameList_t";}
+ using parent_t = WLANMeasConfigNameList;
+ static constexpr bool optional = true;
+
+ };
+ wlanMeasConfigNameList_t& set_wlanMeasConfigNameList() { wlanMeasConfigNameList.setpresent(true); return wlanMeasConfigNameList;}
+ wlanMeasConfigNameList_t const* get_wlanMeasConfigNameList() const {return wlanMeasConfigNameList.is_valid() ? &wlanMeasConfigNameList : nullptr;}
+ struct wlan_rssi_t : asn::enumerated<1, 0, true>
+ {
+ static constexpr const char* name() {return "wlan_rssi_t";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ True
+ } index_t;
+
+ };
+
+ wlan_rssi_t& set_wlan_rssi() { wlan_rssi.setpresent(true); return wlan_rssi;}
+ wlan_rssi_t const* get_wlan_rssi() const {return wlan_rssi.is_valid() ? &wlan_rssi : nullptr;}
+ struct wlan_rtt_t : asn::enumerated<1, 0, true>
+ {
+ static constexpr const char* name() {return "wlan_rtt_t";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ True
+ } index_t;
+
+ };
+
+ wlan_rtt_t& set_wlan_rtt() { wlan_rtt.setpresent(true); return wlan_rtt;}
+ wlan_rtt_t const* get_wlan_rtt() const {return wlan_rtt.is_valid() ? &wlan_rtt : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(wlanMeasConfig);
+ v(wlanMeasConfigNameList);
+ v(wlan_rssi);
+ v(wlan_rtt);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(wlanMeasConfig);
+ v(wlanMeasConfigNameList);
+ v(wlan_rssi);
+ v(wlan_rtt);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ wlanMeasConfig.clear();
+ wlanMeasConfigNameList.clear();
+ wlan_rssi.clear();
+ wlan_rtt.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ wlanMeasConfig_t wlanMeasConfig;
+ wlanMeasConfigNameList_t wlanMeasConfigNameList;
+ wlan_rssi_t wlan_rssi;
+ wlan_rtt_t wlan_rtt;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MDT-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ {ID id-M3Configuration CRITICALITY ignore EXTENSION M3Configuration PRESENCE conditional}|
+ {ID id-M4Configuration CRITICALITY ignore EXTENSION M4Configuration PRESENCE conditional}|
+ {ID id-M5Configuration CRITICALITY ignore EXTENSION M5Configuration PRESENCE conditional}|
+ {ID id-MDT-Location-Info CRITICALITY ignore EXTENSION MDT-Location-Info PRESENCE optional}|
+ {ID id-SignallingBasedMDTPLMNList CRITICALITY ignore EXTENSION MDTPLMNList PRESENCE optional}|
+ {ID id-M6Configuration CRITICALITY ignore EXTENSION M6Configuration PRESENCE conditional}|
+ {ID id-M7Configuration CRITICALITY ignore EXTENSION M7Configuration PRESENCE conditional}|
+ { ID id-BluetoothMeasurementConfiguration CRITICALITY ignore EXTENSION BluetoothMeasurementConfiguration PRESENCE optional}|
+ { ID id-WLANMeasurementConfiguration CRITICALITY ignore EXTENSION WLANMeasurementConfiguration PRESENCE optional},
+ ...
+}
+*/
+
+struct MDT_Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_M3Configuration() { set(id_M3Configuration); type=1;}
+ void select_id_M4Configuration() { set(id_M4Configuration); type=2;}
+ void select_id_M5Configuration() { set(id_M5Configuration); type=3;}
+ void select_id_MDT_Location_Info() { set(id_MDT_Location_Info); type=4;}
+ void select_id_SignallingBasedMDTPLMNList() { set(id_SignallingBasedMDTPLMNList); type=5;}
+ void select_id_M6Configuration() { set(id_M6Configuration); type=6;}
+ void select_id_M7Configuration() { set(id_M7Configuration); type=7;}
+ void select_id_BluetoothMeasurementConfiguration() { set(id_BluetoothMeasurementConfiguration); type=8;}
+ void select_id_WLANMeasurementConfiguration() { set(id_WLANMeasurementConfiguration); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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_M3Configuration)) { type = 1; return true; }
+ else if(equal(id_M4Configuration)) { type = 2; return true; }
+ else if(equal(id_M5Configuration)) { type = 3; return true; }
+ else if(equal(id_MDT_Location_Info)) { type = 4; return true; }
+ else if(equal(id_SignallingBasedMDTPLMNList)) { type = 5; return true; }
+ else if(equal(id_M6Configuration)) { type = 6; return true; }
+ else if(equal(id_M7Configuration)) { type = 7; return true; }
+ else if(equal(id_BluetoothMeasurementConfiguration)) { type = 8; return true; }
+ else if(equal(id_WLANMeasurementConfiguration)) { type = 9; return true; }
+ else { type = 10; 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_M3Configuration);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_M4Configuration);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_M5Configuration);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(id_MDT_Location_Info);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(id_SignallingBasedMDTPLMNList);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(id_M6Configuration);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(id_M7Configuration);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(id_BluetoothMeasurementConfiguration);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(id_WLANMeasurementConfiguration);} return false;
+ case 10: type = 10; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_M3Configuration() { set(ignore); type=1;}
+ void select_id_M4Configuration() { set(ignore); type=2;}
+ void select_id_M5Configuration() { set(ignore); type=3;}
+ void select_id_MDT_Location_Info() { set(ignore); type=4;}
+ void select_id_SignallingBasedMDTPLMNList() { set(ignore); type=5;}
+ void select_id_M6Configuration() { set(ignore); type=6;}
+ void select_id_M7Configuration() { set(ignore); type=7;}
+ void select_id_BluetoothMeasurementConfiguration() { set(ignore); type=8;}
+ void select_id_WLANMeasurementConfiguration() { set(ignore); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { type = 2; return true; }
+ else if(equal(ignore)) { type = 3; return true; }
+ else if(equal(ignore)) { type = 4; return true; }
+ else if(equal(ignore)) { type = 5; return true; }
+ else if(equal(ignore)) { type = 6; return true; }
+ else if(equal(ignore)) { type = 7; return true; }
+ else if(equal(ignore)) { type = 8; return true; }
+ else if(equal(ignore)) { type = 9; return true; }
+ else { type = 10; 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; 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; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 10: type = 10; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ M3Configuration& select_id_M3Configuration() { return set<M3Configuration>(1); }
+ M3Configuration const* get_id_M3Configuration() const { return get<M3Configuration>(1); }
+ M4Configuration& select_id_M4Configuration() { return set<M4Configuration>(2); }
+ M4Configuration const* get_id_M4Configuration() const { return get<M4Configuration>(2); }
+ M5Configuration& select_id_M5Configuration() { return set<M5Configuration>(3); }
+ M5Configuration const* get_id_M5Configuration() const { return get<M5Configuration>(3); }
+ MDT_Location_Info& select_id_MDT_Location_Info() { return set<MDT_Location_Info>(4); }
+ MDT_Location_Info const* get_id_MDT_Location_Info() const { return get<MDT_Location_Info>(4); }
+ MDTPLMNList& select_id_SignallingBasedMDTPLMNList() { return set<MDTPLMNList>(5); }
+ MDTPLMNList const* get_id_SignallingBasedMDTPLMNList() const { return get<MDTPLMNList>(5); }
+ M6Configuration& select_id_M6Configuration() { return set<M6Configuration>(6); }
+ M6Configuration const* get_id_M6Configuration() const { return get<M6Configuration>(6); }
+ M7Configuration& select_id_M7Configuration() { return set<M7Configuration>(7); }
+ M7Configuration const* get_id_M7Configuration() const { return get<M7Configuration>(7); }
+ BluetoothMeasurementConfiguration& select_id_BluetoothMeasurementConfiguration() { return set<BluetoothMeasurementConfiguration>(8); }
+ BluetoothMeasurementConfiguration const* get_id_BluetoothMeasurementConfiguration() const { return get<BluetoothMeasurementConfiguration>(8); }
+ WLANMeasurementConfiguration& select_id_WLANMeasurementConfiguration() { return set<WLANMeasurementConfiguration>(9); }
+ WLANMeasurementConfiguration const* get_id_WLANMeasurementConfiguration() const { return get<WLANMeasurementConfiguration>(9); }
+ bool is_unknown() const { return type == 10; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<M3Configuration>(); break;
+ case 2: var.destroy<M4Configuration>(); break;
+ case 3: var.destroy<M5Configuration>(); break;
+ case 4: var.destroy<MDT_Location_Info>(); break;
+ case 5: var.destroy<MDTPLMNList>(); break;
+ case 6: var.destroy<M6Configuration>(); break;
+ case 7: var.destroy<M7Configuration>(); break;
+ case 8: var.destroy<BluetoothMeasurementConfiguration>(); break;
+ case 9: var.destroy<WLANMeasurementConfiguration>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<M3Configuration>(1);
+ v.template operator()<M4Configuration>(2);
+ v.template operator()<M5Configuration>(3);
+ v.template operator()<MDT_Location_Info>(4);
+ v.template operator()<MDTPLMNList>(5);
+ v.template operator()<M6Configuration>(6);
+ v.template operator()<M7Configuration>(7);
+ v.template operator()<BluetoothMeasurementConfiguration>(8);
+ v.template operator()<WLANMeasurementConfiguration>(9);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_M3Configuration()); return true;
+ case 2: v(select_id_M4Configuration()); return true;
+ case 3: v(select_id_M5Configuration()); return true;
+ case 4: v(select_id_MDT_Location_Info()); return true;
+ case 5: v(select_id_SignallingBasedMDTPLMNList()); return true;
+ case 6: v(select_id_M6Configuration()); return true;
+ case 7: v(select_id_M7Configuration()); return true;
+ case 8: v(select_id_BluetoothMeasurementConfiguration()); return true;
+ case 9: v(select_id_WLANMeasurementConfiguration()); return true;
+ case 10: if(type != 10) {clear(); asn::base::set();} type = 10; 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<M3Configuration>()); return true;
+ case 2: v(var.as<M4Configuration>()); return true;
+ case 3: v(var.as<M5Configuration>()); return true;
+ case 4: v(var.as<MDT_Location_Info>()); return true;
+ case 5: v(var.as<MDTPLMNList>()); return true;
+ case 6: v(var.as<M6Configuration>()); return true;
+ case 7: v(var.as<M7Configuration>()); return true;
+ case 8: v(var.as<BluetoothMeasurementConfiguration>()); return true;
+ case 9: v(var.as<WLANMeasurementConfiguration>()); 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(BluetoothMeasurementConfiguration)];
+ char dummy2[sizeof(M3Configuration)];
+ char dummy3[sizeof(M4Configuration)];
+ char dummy4[sizeof(M5Configuration)];
+ char dummy5[sizeof(M6Configuration)];
+ char dummy6[sizeof(M7Configuration)];
+ char dummy7[sizeof(MDTPLMNList)];
+ char dummy8[sizeof(MDT_Location_Info)];
+ char dummy9[sizeof(WLANMeasurementConfiguration)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_M3Configuration() { set(conditional); type=1;}
+ void select_id_M4Configuration() { set(conditional); type=2;}
+ void select_id_M5Configuration() { set(conditional); type=3;}
+ void select_id_MDT_Location_Info() { set(optional); type=4;}
+ void select_id_SignallingBasedMDTPLMNList() { set(optional); type=5;}
+ void select_id_M6Configuration() { set(conditional); type=6;}
+ void select_id_M7Configuration() { set(conditional); type=7;}
+ void select_id_BluetoothMeasurementConfiguration() { set(optional); type=8;}
+ void select_id_WLANMeasurementConfiguration() { set(optional); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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(conditional)) { type = 1; return true; }
+ else if(equal(conditional)) { type = 2; return true; }
+ else if(equal(conditional)) { type = 3; return true; }
+ else if(equal(optional)) { type = 4; return true; }
+ else if(equal(optional)) { type = 5; return true; }
+ else if(equal(conditional)) { type = 6; return true; }
+ else if(equal(conditional)) { type = 7; return true; }
+ else if(equal(optional)) { type = 8; return true; }
+ else if(equal(optional)) { type = 9; return true; }
+ else { type = 10; 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(conditional);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(conditional);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
+ case 10: type = 10; 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};
+
+ };
+
+};
+/*
+MDT-Configuration ::= SEQUENCE {
+ mdt-Activation MDT-Activation,
+ areaScopeOfMDT AreaScopeOfMDT,
+ measurementsToActivate MeasurementsToActivate,
+ m1reportingTrigger M1ReportingTrigger,
+ m1thresholdeventA2 M1ThresholdEventA2 OPTIONAL,
+-- Included in case of event-triggered, or event-triggered periodic reporting for measurement M1
+ m1periodicReporting M1PeriodicReporting OPTIONAL,
+-- Included in case of periodic, or event-triggered periodic reporting for measurement M1
+ iE-Extensions ProtocolExtensionContainer { {MDT-Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct MDT_Configuration : asn::sequence<7, 0, true, 3>
+{
+ static constexpr const char* name() {return "MDT-Configuration";}
+ using parent_t = asn::sequence<7, 0, true, 3>;
+ struct mdt_Activation_t : MDT_Activation
+ {
+ static constexpr const char* name() {return "mdt_Activation_t";}
+ using parent_t = MDT_Activation;
+
+ };
+ mdt_Activation_t& ref_mdt_Activation() {return mdt_Activation;}
+ mdt_Activation_t const& ref_mdt_Activation() const {return mdt_Activation;}
+ struct areaScopeOfMDT_t : AreaScopeOfMDT
+ {
+ static constexpr const char* name() {return "areaScopeOfMDT_t";}
+ using parent_t = AreaScopeOfMDT;
+
+ };
+ areaScopeOfMDT_t& ref_areaScopeOfMDT() {return areaScopeOfMDT;}
+ areaScopeOfMDT_t const& ref_areaScopeOfMDT() const {return areaScopeOfMDT;}
+ struct measurementsToActivate_t : MeasurementsToActivate
+ {
+ static constexpr const char* name() {return "measurementsToActivate_t";}
+ using parent_t = MeasurementsToActivate;
+
+ };
+ measurementsToActivate_t& ref_measurementsToActivate() {return measurementsToActivate;}
+ measurementsToActivate_t const& ref_measurementsToActivate() const {return measurementsToActivate;}
+ struct m1reportingTrigger_t : M1ReportingTrigger
+ {
+ static constexpr const char* name() {return "m1reportingTrigger_t";}
+ using parent_t = M1ReportingTrigger;
+
+ };
+ m1reportingTrigger_t& ref_m1reportingTrigger() {return m1reportingTrigger;}
+ m1reportingTrigger_t const& ref_m1reportingTrigger() const {return m1reportingTrigger;}
+ struct m1thresholdeventA2_t : M1ThresholdEventA2
+ {
+ static constexpr const char* name() {return "m1thresholdeventA2_t";}
+ using parent_t = M1ThresholdEventA2;
+ static constexpr bool optional = true;
+
+ };
+ m1thresholdeventA2_t& set_m1thresholdeventA2() { m1thresholdeventA2.setpresent(true); return m1thresholdeventA2;}
+ m1thresholdeventA2_t const* get_m1thresholdeventA2() const {return m1thresholdeventA2.is_valid() ? &m1thresholdeventA2 : nullptr;}
+ struct m1periodicReporting_t : M1PeriodicReporting
+ {
+ static constexpr const char* name() {return "m1periodicReporting_t";}
+ using parent_t = M1PeriodicReporting;
+ static constexpr bool optional = true;
+
+ };
+ m1periodicReporting_t& set_m1periodicReporting() { m1periodicReporting.setpresent(true); return m1periodicReporting;}
+ m1periodicReporting_t const* get_m1periodicReporting() const {return m1periodicReporting.is_valid() ? &m1periodicReporting : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<MDT_Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<MDT_Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(mdt_Activation);
+ v(areaScopeOfMDT);
+ v(measurementsToActivate);
+ v(m1reportingTrigger);
+ v(m1thresholdeventA2);
+ v(m1periodicReporting);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(mdt_Activation);
+ v(areaScopeOfMDT);
+ v(measurementsToActivate);
+ v(m1reportingTrigger);
+ v(m1thresholdeventA2);
+ v(m1periodicReporting);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ mdt_Activation.clear();
+ areaScopeOfMDT.clear();
+ measurementsToActivate.clear();
+ m1reportingTrigger.clear();
+ m1thresholdeventA2.clear();
+ m1periodicReporting.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ mdt_Activation_t mdt_Activation;
+ areaScopeOfMDT_t areaScopeOfMDT;
+ measurementsToActivate_t measurementsToActivate;
+ m1reportingTrigger_t m1reportingTrigger;
+ m1thresholdeventA2_t m1thresholdeventA2;
+ m1periodicReporting_t m1periodicReporting;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MakeBeforeBreakIndicator::= ENUMERATED {true, ...}
+*/
+
+struct MakeBeforeBreakIndicator : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "MakeBeforeBreakIndicator";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ True
+ } index_t;
+
+};
+
+/*
+ManagementBasedMDTallowed ::= ENUMERATED {allowed, ...}
+*/
+
+struct ManagementBasedMDTallowed : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "ManagementBasedMDTallowed";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ allowed
+ } index_t;
+
+};
+
+/*
+Masked-IMEISV ::= BIT STRING (SIZE (64))
+*/
+
+struct Masked_IMEISV : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<64>>;
+ static constexpr const char* name() {return "Masked-IMEISV";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+MeNBCoordinationAssistanceInformation ::= ENUMERATED{
+ coordination-not-required,
+ ...
+}
+*/
+
+struct MeNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "MeNBCoordinationAssistanceInformation";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ coordination_not_required
+ } index_t;
+
+};
+
+/*
+NRCellIdentifier ::= BIT STRING (SIZE (36))
+*/
+
+struct NRCellIdentifier : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<36>>;
+ static constexpr const char* name() {return "NRCellIdentifier";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRCGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct NRCGI_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+NRCGI ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ nRcellIdentifier NRCellIdentifier,
+ iE-Extensions ProtocolExtensionContainer { {NRCGI-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct NRCGI : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "NRCGI";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct nRcellIdentifier_t : NRCellIdentifier
+ {
+ static constexpr const char* name() {return "nRcellIdentifier_t";}
+ using parent_t = NRCellIdentifier;
+
+ };
+ nRcellIdentifier_t& ref_nRcellIdentifier() {return nRcellIdentifier;}
+ nRcellIdentifier_t const& ref_nRcellIdentifier() const {return nRcellIdentifier;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<NRCGI_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<NRCGI_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(nRcellIdentifier);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(nRcellIdentifier);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ nRcellIdentifier.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ nRcellIdentifier_t nRcellIdentifier;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MeNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-NRCGI CRITICALITY ignore EXTENSION NRCGI PRESENCE optional}|
+ { ID id-MeNBCoordinationAssistanceInformation CRITICALITY reject EXTENSION MeNBCoordinationAssistanceInformation PRESENCE optional},
+ ...
+}
+*/
+
+struct MeNBResourceCoordinationInformationExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NRCGI() { set(id_NRCGI); type=1;}
+ void select_id_MeNBCoordinationAssistanceInformation() { set(id_MeNBCoordinationAssistanceInformation); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_NRCGI)) { type = 1; return true; }
+ else if(equal(id_MeNBCoordinationAssistanceInformation)) { 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_NRCGI);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_MeNBCoordinationAssistanceInformation);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NRCGI() { set(ignore); type=1;}
+ void select_id_MeNBCoordinationAssistanceInformation() { set(reject); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 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(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ NRCGI& select_id_NRCGI() { return set<NRCGI>(1); }
+ NRCGI const* get_id_NRCGI() const { return get<NRCGI>(1); }
+ MeNBCoordinationAssistanceInformation& select_id_MeNBCoordinationAssistanceInformation() { return set<MeNBCoordinationAssistanceInformation>(2); }
+ MeNBCoordinationAssistanceInformation const* get_id_MeNBCoordinationAssistanceInformation() const { return get<MeNBCoordinationAssistanceInformation>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<NRCGI>(); break;
+ case 2: var.destroy<MeNBCoordinationAssistanceInformation>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<NRCGI>(1);
+ v.template operator()<MeNBCoordinationAssistanceInformation>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_NRCGI()); return true;
+ case 2: v(select_id_MeNBCoordinationAssistanceInformation()); 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<NRCGI>()); return true;
+ case 2: v(var.as<MeNBCoordinationAssistanceInformation>()); 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(MeNBCoordinationAssistanceInformation)];
+ char dummy2[sizeof(NRCGI)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NRCGI() { set(optional); type=1;}
+ void select_id_MeNBCoordinationAssistanceInformation() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+MeNBResourceCoordinationInformation ::= SEQUENCE {
+ eUTRA-Cell-ID ECGI,
+ uLCoordinationInformation BIT STRING (SIZE(6..4400, ...)),
+ dLCoordinationInformation BIT STRING (SIZE(6..4400, ...)) OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {MeNBResourceCoordinationInformationExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct MeNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "MeNBResourceCoordinationInformation";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct eUTRA_Cell_ID_t : ECGI
+ {
+ static constexpr const char* name() {return "eUTRA_Cell_ID_t";}
+ using parent_t = ECGI;
+
+ };
+ eUTRA_Cell_ID_t& ref_eUTRA_Cell_ID() {return eUTRA_Cell_ID;}
+ eUTRA_Cell_ID_t const& ref_eUTRA_Cell_ID() const {return eUTRA_Cell_ID;}
+ struct uLCoordinationInformation_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+ static constexpr const char* name() {return "uLCoordinationInformation_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
+ uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
+ struct dLCoordinationInformation_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+ static constexpr const char* name() {return "dLCoordinationInformation_t";}
+ using parent_t = asn::bstring<>;
+ static constexpr bool optional = true;
+
+ };
+
+ dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
+ dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eUTRA_Cell_ID);
+ v(uLCoordinationInformation);
+ v(dLCoordinationInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eUTRA_Cell_ID);
+ v(uLCoordinationInformation);
+ v(dLCoordinationInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ eUTRA_Cell_ID.clear();
+ uLCoordinationInformation.clear();
+ dLCoordinationInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ eUTRA_Cell_ID_t eUTRA_Cell_ID;
+ uLCoordinationInformation_t uLCoordinationInformation;
+ dLCoordinationInformation_t dLCoordinationInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+MeNBtoSeNBContainer ::= OCTET STRING
+*/
+
+struct MeNBtoSeNBContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "MeNBtoSeNBContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+MeNBtoSgNBContainer ::= OCTET STRING
+*/
+
+struct MeNBtoSgNBContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "MeNBtoSgNBContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+Measurement-ID ::= INTEGER (1..4095, ...)
+*/
+
+struct Measurement_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 4095>>;
+ static constexpr const char* name() {return "Measurement-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+MobilityParametersInformation ::= SEQUENCE {
+ handoverTriggerChange INTEGER (-20..20),
+ ...
+}
+*/
+
+struct MobilityParametersInformation : asn::sequence<1, 0, true, 0>
+{
+ static constexpr const char* name() {return "MobilityParametersInformation";}
+ using parent_t = asn::sequence<1, 0, true, 0>;
+ struct handoverTriggerChange_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+ static constexpr const char* name() {return "handoverTriggerChange_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ handoverTriggerChange_t& ref_handoverTriggerChange() {return handoverTriggerChange;}
+ handoverTriggerChange_t const& ref_handoverTriggerChange() const {return handoverTriggerChange;}
+ template<typename V> void decode(V& v)
+ {
+ v(handoverTriggerChange);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(handoverTriggerChange);
+
+ };
+ void clear()
+ {
+ handoverTriggerChange.clear();
+
+ };
+ private:
+ handoverTriggerChange_t handoverTriggerChange;
+
+};
+/*
+MobilityParametersModificationRange ::= SEQUENCE {
+ handoverTriggerChangeLowerLimit INTEGER (-20..20),
+ handoverTriggerChangeUpperLimit INTEGER (-20..20),
+ ...
+}
+*/
+
+struct MobilityParametersModificationRange : asn::sequence<2, 0, true, 0>
+{
+ static constexpr const char* name() {return "MobilityParametersModificationRange";}
+ using parent_t = asn::sequence<2, 0, true, 0>;
+ struct handoverTriggerChangeLowerLimit_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+ static constexpr const char* name() {return "handoverTriggerChangeLowerLimit_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ handoverTriggerChangeLowerLimit_t& ref_handoverTriggerChangeLowerLimit() {return handoverTriggerChangeLowerLimit;}
+ handoverTriggerChangeLowerLimit_t const& ref_handoverTriggerChangeLowerLimit() const {return handoverTriggerChangeLowerLimit;}
+ struct handoverTriggerChangeUpperLimit_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
+ static constexpr const char* name() {return "handoverTriggerChangeUpperLimit_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ handoverTriggerChangeUpperLimit_t& ref_handoverTriggerChangeUpperLimit() {return handoverTriggerChangeUpperLimit;}
+ handoverTriggerChangeUpperLimit_t const& ref_handoverTriggerChangeUpperLimit() const {return handoverTriggerChangeUpperLimit;}
+ template<typename V> void decode(V& v)
+ {
+ v(handoverTriggerChangeLowerLimit);
+ v(handoverTriggerChangeUpperLimit);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(handoverTriggerChangeLowerLimit);
+ v(handoverTriggerChangeUpperLimit);
+
+ };
+ void clear()
+ {
+ handoverTriggerChangeLowerLimit.clear();
+ handoverTriggerChangeUpperLimit.clear();
+
+ };
+ private:
+ handoverTriggerChangeLowerLimit_t handoverTriggerChangeLowerLimit;
+ handoverTriggerChangeUpperLimit_t handoverTriggerChangeUpperLimit;
+
+};
+/*
+MultibandInfoList ::= SEQUENCE (SIZE(1..maxnoofBands)) OF BandInfo
+*/
+
+struct MultibandInfoList_elm : BandInfo
+{
+ static constexpr const char* name() {return "MultibandInfoList_elm";}
+ using parent_t = BandInfo;
+
+};
+struct MultibandInfoList : asn::sequenceof<MultibandInfoList_elm>
+{
+ static constexpr const char* name() {return "MultibandInfoList";}
+ using parent_t = asn::sequenceof<MultibandInfoList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofBands >>;
+
+};
+/*
+NRSCS ::= ENUMERATED { scs15, scs30, scs60, scs120, ...}
+*/
+
+struct NRSCS : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "NRSCS";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ scs15
+ ,scs30
+ ,scs60
+ ,scs120
+ } index_t;
+
+};
+
+/*
+NRNRB ::= ENUMERATED { nrb11, nrb18, nrb24, nrb25, nrb31, nrb32, nrb38, nrb51, nrb52, nrb65, nrb66, nrb78, nrb79, nrb93, nrb106, nrb107, nrb121, nrb132, nrb133, nrb135, nrb160, nrb162, nrb189, nrb216, nrb217, nrb245, nrb264, nrb270, nrb273, ...}
+*/
+
+struct NRNRB : asn::enumerated<29, 0, true>
+{
+ static constexpr const char* name() {return "NRNRB";}
+ using parent_t = asn::enumerated<29, 0, true>;
+ typedef enum {
+ nrb11
+ ,nrb18
+ ,nrb24
+ ,nrb25
+ ,nrb31
+ ,nrb32
+ ,nrb38
+ ,nrb51
+ ,nrb52
+ ,nrb65
+ ,nrb66
+ ,nrb78
+ ,nrb79
+ ,nrb93
+ ,nrb106
+ ,nrb107
+ ,nrb121
+ ,nrb132
+ ,nrb133
+ ,nrb135
+ ,nrb160
+ ,nrb162
+ ,nrb189
+ ,nrb216
+ ,nrb217
+ ,nrb245
+ ,nrb264
+ ,nrb270
+ ,nrb273
+ } index_t;
+
+};
+
+/*
+NR-TxBW-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct NR_TxBW_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+NR-TxBW ::= SEQUENCE {
+ nRSCS NRSCS,
+ nRNRB NRNRB,
+ iE-Extensions ProtocolExtensionContainer { {NR-TxBW-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct NR_TxBW : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "NR-TxBW";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct nRSCS_t : NRSCS
+ {
+ static constexpr const char* name() {return "nRSCS_t";}
+ using parent_t = NRSCS;
+
+ };
+ nRSCS_t& ref_nRSCS() {return nRSCS;}
+ nRSCS_t const& ref_nRSCS() const {return nRSCS;}
+ struct nRNRB_t : NRNRB
+ {
+ static constexpr const char* name() {return "nRNRB_t";}
+ using parent_t = NRNRB;
+
+ };
+ nRNRB_t& ref_nRNRB() {return nRNRB;}
+ nRNRB_t const& ref_nRNRB() const {return nRNRB;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<NR_TxBW_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<NR_TxBW_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(nRSCS);
+ v(nRNRB);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(nRSCS);
+ v(nRNRB);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ nRSCS.clear();
+ nRNRB.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ nRSCS_t nRSCS;
+ nRNRB_t nRNRB;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SULInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SULInformation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SULInformation ::= SEQUENCE {
+ sUL-ARFCN INTEGER (0.. 3279165),
+ sUL-TxBW NR-TxBW,
+ iE-Extensions ProtocolExtensionContainer { {SULInformation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SULInformation : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "SULInformation";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct sUL_ARFCN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
+ static constexpr const char* name() {return "sUL_ARFCN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ sUL_ARFCN_t& ref_sUL_ARFCN() {return sUL_ARFCN;}
+ sUL_ARFCN_t const& ref_sUL_ARFCN() const {return sUL_ARFCN;}
+ struct sUL_TxBW_t : NR_TxBW
+ {
+ static constexpr const char* name() {return "sUL_TxBW_t";}
+ using parent_t = NR_TxBW;
+
+ };
+ sUL_TxBW_t& ref_sUL_TxBW() {return sUL_TxBW;}
+ sUL_TxBW_t const& ref_sUL_TxBW() const {return sUL_TxBW;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SULInformation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SULInformation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(sUL_ARFCN);
+ v(sUL_TxBW);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(sUL_ARFCN);
+ v(sUL_TxBW);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ sUL_ARFCN.clear();
+ sUL_TxBW.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ sUL_ARFCN_t sUL_ARFCN;
+ sUL_TxBW_t sUL_TxBW;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+NRFreqInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct NRFreqInfo_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+NRFreqInfo ::= SEQUENCE{
+ nRARFCN INTEGER (0.. 3279165),
+ freqBandListNr SEQUENCE (SIZE(1..maxnoofNrCellBands)) OF FreqBandNrItem,
+ sULInformation SULInformation OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {NRFreqInfo-ExtIEs} } OPTIONAL,
+
+ ...
+}
+*/
+
+struct NRFreqInfo : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "NRFreqInfo";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct nRARFCN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
+ static constexpr const char* name() {return "nRARFCN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ nRARFCN_t& ref_nRARFCN() {return nRARFCN;}
+ nRARFCN_t const& ref_nRARFCN() const {return nRARFCN;}
+ struct freqBandListNr_t_elm : FreqBandNrItem
+ {
+ static constexpr const char* name() {return "freqBandListNr_t_elm";}
+ using parent_t = FreqBandNrItem;
+
+ };
+ struct freqBandListNr_t : asn::sequenceof<freqBandListNr_t_elm>
+ {
+ static constexpr const char* name() {return "freqBandListNr_t";}
+ using parent_t = asn::sequenceof<freqBandListNr_t_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofNrCellBands >>;
+
+ };
+ freqBandListNr_t& ref_freqBandListNr() {return freqBandListNr;}
+ freqBandListNr_t const& ref_freqBandListNr() const {return freqBandListNr;}
+ struct sULInformation_t : SULInformation
+ {
+ static constexpr const char* name() {return "sULInformation_t";}
+ using parent_t = SULInformation;
+ static constexpr bool optional = true;
+
+ };
+ sULInformation_t& set_sULInformation() { sULInformation.setpresent(true); return sULInformation;}
+ sULInformation_t const* get_sULInformation() const {return sULInformation.is_valid() ? &sULInformation : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<NRFreqInfo_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<NRFreqInfo_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(nRARFCN);
+ v(freqBandListNr);
+ v(sULInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(nRARFCN);
+ v(freqBandListNr);
+ v(sULInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ nRARFCN.clear();
+ freqBandListNr.clear();
+ sULInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ nRARFCN_t nRARFCN;
+ freqBandListNr_t freqBandListNr;
+ sULInformation_t sULInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+NRPCI ::= INTEGER (0..1007)
+*/
+
+struct NRPCI : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 1007>>;
+ static constexpr const char* name() {return "NRPCI";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+NRencryptionAlgorithms ::= BIT STRING (SIZE (16,...))
+*/
+
+struct NRencryptionAlgorithms : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::one<16>>;
+ static constexpr const char* name() {return "NRencryptionAlgorithms";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRintegrityProtectionAlgorithms ::= BIT STRING (SIZE (16,...))
+*/
+
+struct NRintegrityProtectionAlgorithms : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::one<16>>;
+ static constexpr const char* name() {return "NRintegrityProtectionAlgorithms";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+NRUESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct NRUESecurityCapabilities_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+NRUESecurityCapabilities ::= SEQUENCE {
+ nRencryptionAlgorithms NRencryptionAlgorithms,
+ nRintegrityProtectionAlgorithms NRintegrityProtectionAlgorithms,
+ iE-Extensions ProtocolExtensionContainer { {NRUESecurityCapabilities-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct NRUESecurityCapabilities : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "NRUESecurityCapabilities";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct nRencryptionAlgorithms_t : NRencryptionAlgorithms
+ {
+ static constexpr const char* name() {return "nRencryptionAlgorithms_t";}
+ using parent_t = NRencryptionAlgorithms;
+
+ };
+ nRencryptionAlgorithms_t& ref_nRencryptionAlgorithms() {return nRencryptionAlgorithms;}
+ nRencryptionAlgorithms_t const& ref_nRencryptionAlgorithms() const {return nRencryptionAlgorithms;}
+ struct nRintegrityProtectionAlgorithms_t : NRintegrityProtectionAlgorithms
+ {
+ static constexpr const char* name() {return "nRintegrityProtectionAlgorithms_t";}
+ using parent_t = NRintegrityProtectionAlgorithms;
+
+ };
+ nRintegrityProtectionAlgorithms_t& ref_nRintegrityProtectionAlgorithms() {return nRintegrityProtectionAlgorithms;}
+ nRintegrityProtectionAlgorithms_t const& ref_nRintegrityProtectionAlgorithms() const {return nRintegrityProtectionAlgorithms;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(nRencryptionAlgorithms);
+ v(nRintegrityProtectionAlgorithms);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(nRencryptionAlgorithms);
+ v(nRintegrityProtectionAlgorithms);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ nRencryptionAlgorithms.clear();
+ nRintegrityProtectionAlgorithms.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ nRencryptionAlgorithms_t nRencryptionAlgorithms;
+ nRintegrityProtectionAlgorithms_t nRintegrityProtectionAlgorithms;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PCI ::= INTEGER (0..503, ...)
+*/
+
+struct PCI : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<0, 503>>;
+ static constexpr const char* name() {return "PCI";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+Neighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-NeighbourTAC CRITICALITY ignore EXTENSION TAC PRESENCE optional}|
+ { ID id-eARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional},
+ ...
+}
+*/
+
+struct Neighbour_Information_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NeighbourTAC() { set(id_NeighbourTAC); type=1;}
+ void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_NeighbourTAC)) { type = 1; return true; }
+ else if(equal(id_eARFCNExtension)) { 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_NeighbourTAC);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NeighbourTAC() { set(ignore); type=1;}
+ void select_id_eARFCNExtension() { set(reject); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 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(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ TAC& select_id_NeighbourTAC() { return set<TAC>(1); }
+ TAC const* get_id_NeighbourTAC() const { return get<TAC>(1); }
+ EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
+ EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<TAC>(); break;
+ case 2: var.destroy<EARFCNExtension>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<TAC>(1);
+ v.template operator()<EARFCNExtension>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_NeighbourTAC()); return true;
+ case 2: v(select_id_eARFCNExtension()); 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<TAC>()); return true;
+ case 2: v(var.as<EARFCNExtension>()); 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(EARFCNExtension)];
+ char dummy2[sizeof(TAC)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_NeighbourTAC() { set(optional); type=1;}
+ void select_id_eARFCNExtension() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+Neighbour-Information ::= SEQUENCE (SIZE (0..maxnoofNeighbours)) OF SEQUENCE {
+ eCGI ECGI,
+ pCI PCI,
+ eARFCN EARFCN,
+ iE-Extensions ProtocolExtensionContainer { {Neighbour-Information-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct Neighbour_Information_elm : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "Neighbour_Information_elm";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct eCGI_t : ECGI
+ {
+ static constexpr const char* name() {return "eCGI_t";}
+ using parent_t = ECGI;
+
+ };
+ eCGI_t& ref_eCGI() {return eCGI;}
+ eCGI_t const& ref_eCGI() const {return eCGI;}
+ struct pCI_t : PCI
+ {
+ static constexpr const char* name() {return "pCI_t";}
+ using parent_t = PCI;
+
+ };
+ pCI_t& ref_pCI() {return pCI;}
+ pCI_t const& ref_pCI() const {return pCI;}
+ struct eARFCN_t : EARFCN
+ {
+ static constexpr const char* name() {return "eARFCN_t";}
+ using parent_t = EARFCN;
+
+ };
+ eARFCN_t& ref_eARFCN() {return eARFCN;}
+ eARFCN_t const& ref_eARFCN() const {return eARFCN;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<Neighbour_Information_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<Neighbour_Information_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eCGI);
+ v(pCI);
+ v(eARFCN);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eCGI);
+ v(pCI);
+ v(eARFCN);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ eCGI.clear();
+ pCI.clear();
+ eARFCN.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ eCGI_t eCGI;
+ pCI_t pCI;
+ eARFCN_t eARFCN;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct Neighbour_Information : asn::sequenceof<Neighbour_Information_elm>
+{
+ static constexpr const char* name() {return "Neighbour-Information";}
+ using parent_t = asn::sequenceof<Neighbour_Information_elm>;
+ using constraint_t = asn::constraints<false,asn::span<0, maxnoofNeighbours >>;
+
+};
+/*
+NewDRBIDrequest::= ENUMERATED {true, ...}
+*/
+
+struct NewDRBIDrequest : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "NewDRBIDrequest";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ True
+ } index_t;
+
+};
+
+/*
+Number-of-Antennaports ::= ENUMERATED {
+ an1,
+ an2,
+ an4,
+ ...
+}
+*/
+
+struct Number_of_Antennaports : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "Number-of-Antennaports";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ an1
+ ,an2
+ ,an4
+ } index_t;
+
+};
+
+/*
+PDCPChangeIndication ::= ENUMERATED {s-KgNB-update-required, pDCP-data-recovery-required,...}
+*/
+
+struct PDCPChangeIndication : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "PDCPChangeIndication";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ s_KgNB_update_required
+ ,pDCP_data_recovery_required
+ } index_t;
+
+};
+
+/*
+PDCPSnLength ::= ENUMERATED {twelve-bits,eighteen-bits,...}
+*/
+
+struct PDCPSnLength : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "PDCPSnLength";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ twelve_bits
+ ,eighteen_bits
+ } index_t;
+
+};
+
+/*
+PRACH-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct PRACH_Configuration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+PRACH-Configuration ::= SEQUENCE {
+ rootSequenceIndex INTEGER (0..837),
+ zeroCorrelationIndex INTEGER (0..15),
+ highSpeedFlag BOOLEAN,
+ prach-FreqOffset INTEGER (0..94),
+ prach-ConfigIndex INTEGER (0..63) OPTIONAL, -- present for TDD --
+ iE-Extensions ProtocolExtensionContainer { {PRACH-Configuration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct PRACH_Configuration : asn::sequence<6, 0, true, 2>
+{
+ static constexpr const char* name() {return "PRACH-Configuration";}
+ using parent_t = asn::sequence<6, 0, true, 2>;
+ struct rootSequenceIndex_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 837>>;
+ static constexpr const char* name() {return "rootSequenceIndex_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ rootSequenceIndex_t& ref_rootSequenceIndex() {return rootSequenceIndex;}
+ rootSequenceIndex_t const& ref_rootSequenceIndex() const {return rootSequenceIndex;}
+ struct zeroCorrelationIndex_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 15>>;
+ static constexpr const char* name() {return "zeroCorrelationIndex_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ zeroCorrelationIndex_t& ref_zeroCorrelationIndex() {return zeroCorrelationIndex;}
+ zeroCorrelationIndex_t const& ref_zeroCorrelationIndex() const {return zeroCorrelationIndex;}
+ struct highSpeedFlag_t : asn::boolean
+ {
+ static constexpr const char* name() {return "highSpeedFlag_t";}
+ using parent_t = asn::boolean;
+
+ };
+ highSpeedFlag_t& ref_highSpeedFlag() {return highSpeedFlag;}
+ highSpeedFlag_t const& ref_highSpeedFlag() const {return highSpeedFlag;}
+ struct prach_FreqOffset_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 94>>;
+ static constexpr const char* name() {return "prach_FreqOffset_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ prach_FreqOffset_t& ref_prach_FreqOffset() {return prach_FreqOffset;}
+ prach_FreqOffset_t const& ref_prach_FreqOffset() const {return prach_FreqOffset;}
+ struct prach_ConfigIndex_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 63>>;
+ static constexpr const char* name() {return "prach_ConfigIndex_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ prach_ConfigIndex_t& set_prach_ConfigIndex() { prach_ConfigIndex.setpresent(true); return prach_ConfigIndex;}
+ prach_ConfigIndex_t const* get_prach_ConfigIndex() const {return prach_ConfigIndex.is_valid() ? &prach_ConfigIndex : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rootSequenceIndex);
+ v(zeroCorrelationIndex);
+ v(highSpeedFlag);
+ v(prach_FreqOffset);
+ v(prach_ConfigIndex);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rootSequenceIndex);
+ v(zeroCorrelationIndex);
+ v(highSpeedFlag);
+ v(prach_FreqOffset);
+ v(prach_ConfigIndex);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rootSequenceIndex.clear();
+ zeroCorrelationIndex.clear();
+ highSpeedFlag.clear();
+ prach_FreqOffset.clear();
+ prach_ConfigIndex.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rootSequenceIndex_t rootSequenceIndex;
+ zeroCorrelationIndex_t zeroCorrelationIndex;
+ highSpeedFlag_t highSpeedFlag;
+ prach_FreqOffset_t prach_FreqOffset;
+ prach_ConfigIndex_t prach_ConfigIndex;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+PedestrianUE ::= ENUMERATED {
+ authorized,
+ not-authorized,
+ ...
+}
+*/
+
+struct PedestrianUE : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "PedestrianUE";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ authorized
+ ,not_authorized
+ } index_t;
+
+};
+
+/*
+Port-Number ::= OCTET STRING (SIZE (2))
+*/
+
+struct Port_Number : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<2>>;
+ static constexpr const char* name() {return "Port-Number";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+ProSeDirectDiscovery ::= ENUMERATED {
+ authorized,
+ not-authorized,
+ ...
+}
+*/
+
+struct ProSeDirectDiscovery : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "ProSeDirectDiscovery";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ authorized
+ ,not_authorized
+ } index_t;
+
+};
+
+/*
+ProSeDirectCommunication ::= ENUMERATED {
+ authorized,
+ not-authorized,
+ ...
+}
+*/
+
+struct ProSeDirectCommunication : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "ProSeDirectCommunication";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ authorized
+ ,not_authorized
+ } index_t;
+
+};
+
+/*
+ProSeUEtoNetworkRelaying ::= ENUMERATED {
+ authorized,
+ not-authorized,
+ ...
+}
+*/
+
+struct ProSeUEtoNetworkRelaying : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "ProSeUEtoNetworkRelaying";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ authorized
+ ,not_authorized
+ } index_t;
+
+};
+
+/*
+ProSeAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-ProSeUEtoNetworkRelaying CRITICALITY ignore EXTENSION ProSeUEtoNetworkRelaying PRESENCE optional},
+ ...
+}
+*/
+
+struct ProSeAuthorized_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_ProSeUEtoNetworkRelaying() { set(id_ProSeUEtoNetworkRelaying); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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_ProSeUEtoNetworkRelaying)) { 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_ProSeUEtoNetworkRelaying);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_ProSeUEtoNetworkRelaying() { set(ignore); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ ProSeUEtoNetworkRelaying& select_id_ProSeUEtoNetworkRelaying() { return set<ProSeUEtoNetworkRelaying>(1); }
+ ProSeUEtoNetworkRelaying const* get_id_ProSeUEtoNetworkRelaying() const { return get<ProSeUEtoNetworkRelaying>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<ProSeUEtoNetworkRelaying>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<ProSeUEtoNetworkRelaying>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_ProSeUEtoNetworkRelaying()); 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<ProSeUEtoNetworkRelaying>()); 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(ProSeUEtoNetworkRelaying)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_ProSeUEtoNetworkRelaying() { set(optional); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+ProSeAuthorized ::= SEQUENCE {
+ proSeDirectDiscovery ProSeDirectDiscovery OPTIONAL,
+ proSeDirectCommunication ProSeDirectCommunication OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {ProSeAuthorized-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ProSeAuthorized : asn::sequence<3, 0, true, 3>
+{
+ static constexpr const char* name() {return "ProSeAuthorized";}
+ using parent_t = asn::sequence<3, 0, true, 3>;
+ struct proSeDirectDiscovery_t : ProSeDirectDiscovery
+ {
+ static constexpr const char* name() {return "proSeDirectDiscovery_t";}
+ using parent_t = ProSeDirectDiscovery;
+ static constexpr bool optional = true;
+
+ };
+ proSeDirectDiscovery_t& set_proSeDirectDiscovery() { proSeDirectDiscovery.setpresent(true); return proSeDirectDiscovery;}
+ proSeDirectDiscovery_t const* get_proSeDirectDiscovery() const {return proSeDirectDiscovery.is_valid() ? &proSeDirectDiscovery : nullptr;}
+ struct proSeDirectCommunication_t : ProSeDirectCommunication
+ {
+ static constexpr const char* name() {return "proSeDirectCommunication_t";}
+ using parent_t = ProSeDirectCommunication;
+ static constexpr bool optional = true;
+
+ };
+ proSeDirectCommunication_t& set_proSeDirectCommunication() { proSeDirectCommunication.setpresent(true); return proSeDirectCommunication;}
+ proSeDirectCommunication_t const* get_proSeDirectCommunication() const {return proSeDirectCommunication.is_valid() ? &proSeDirectCommunication : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(proSeDirectDiscovery);
+ v(proSeDirectCommunication);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(proSeDirectDiscovery);
+ v(proSeDirectCommunication);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ proSeDirectDiscovery.clear();
+ proSeDirectCommunication.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ proSeDirectDiscovery_t proSeDirectDiscovery;
+ proSeDirectCommunication_t proSeDirectCommunication;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ResourceType ::= ENUMERATED {
+ downlinknonCRS,
+ cRS,
+ uplink,
+ ...
+}
+*/
+
+struct ResourceType : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "ResourceType";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ downlinknonCRS
+ ,cRS
+ ,uplink
+ } index_t;
+
+};
+
+/*
+ProtectedFootprintTimePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ProtectedFootprintTimePattern_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ProtectedFootprintTimePattern ::= SEQUENCE {
+ protectedFootprintTimePeriodicity INTEGER (1..320, ...),
+ protectedFootprintStartTime INTEGER (1..20, ...),
+ iE-Extensions ProtocolExtensionContainer { {ProtectedFootprintTimePattern-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ProtectedFootprintTimePattern : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "ProtectedFootprintTimePattern";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct protectedFootprintTimePeriodicity_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 320>>;
+ static constexpr const char* name() {return "protectedFootprintTimePeriodicity_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ protectedFootprintTimePeriodicity_t& ref_protectedFootprintTimePeriodicity() {return protectedFootprintTimePeriodicity;}
+ protectedFootprintTimePeriodicity_t const& ref_protectedFootprintTimePeriodicity() const {return protectedFootprintTimePeriodicity;}
+ struct protectedFootprintStartTime_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 20>>;
+ static constexpr const char* name() {return "protectedFootprintStartTime_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ protectedFootprintStartTime_t& ref_protectedFootprintStartTime() {return protectedFootprintStartTime;}
+ protectedFootprintStartTime_t const& ref_protectedFootprintStartTime() const {return protectedFootprintStartTime;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(protectedFootprintTimePeriodicity);
+ v(protectedFootprintStartTime);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(protectedFootprintTimePeriodicity);
+ v(protectedFootprintStartTime);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ protectedFootprintTimePeriodicity.clear();
+ protectedFootprintStartTime.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ protectedFootprintTimePeriodicity_t protectedFootprintTimePeriodicity;
+ protectedFootprintStartTime_t protectedFootprintStartTime;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ProtectedResourceList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ProtectedResourceList_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ProtectedResourceList-Item ::= SEQUENCE {
+ resourceType ResourceType,
+ intraPRBProtectedResourceFootprint BIT STRING (SIZE(84, ...)),
+ protectedFootprintFrequencyPattern BIT STRING (SIZE(6..110, ...)),
+ protectedFootprintTimePattern ProtectedFootprintTimePattern,
+ iE-Extensions ProtocolExtensionContainer { {ProtectedResourceList-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ProtectedResourceList_Item : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "ProtectedResourceList-Item";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct resourceType_t : ResourceType
+ {
+ static constexpr const char* name() {return "resourceType_t";}
+ using parent_t = ResourceType;
+
+ };
+ resourceType_t& ref_resourceType() {return resourceType;}
+ resourceType_t const& ref_resourceType() const {return resourceType;}
+ struct intraPRBProtectedResourceFootprint_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::one<84>>;
+ static constexpr const char* name() {return "intraPRBProtectedResourceFootprint_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ intraPRBProtectedResourceFootprint_t& ref_intraPRBProtectedResourceFootprint() {return intraPRBProtectedResourceFootprint;}
+ intraPRBProtectedResourceFootprint_t const& ref_intraPRBProtectedResourceFootprint() const {return intraPRBProtectedResourceFootprint;}
+ struct protectedFootprintFrequencyPattern_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 110>>;
+ static constexpr const char* name() {return "protectedFootprintFrequencyPattern_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ protectedFootprintFrequencyPattern_t& ref_protectedFootprintFrequencyPattern() {return protectedFootprintFrequencyPattern;}
+ protectedFootprintFrequencyPattern_t const& ref_protectedFootprintFrequencyPattern() const {return protectedFootprintFrequencyPattern;}
+ struct protectedFootprintTimePattern_t : ProtectedFootprintTimePattern
+ {
+ static constexpr const char* name() {return "protectedFootprintTimePattern_t";}
+ using parent_t = ProtectedFootprintTimePattern;
+
+ };
+ protectedFootprintTimePattern_t& ref_protectedFootprintTimePattern() {return protectedFootprintTimePattern;}
+ protectedFootprintTimePattern_t const& ref_protectedFootprintTimePattern() const {return protectedFootprintTimePattern;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(resourceType);
+ v(intraPRBProtectedResourceFootprint);
+ v(protectedFootprintFrequencyPattern);
+ v(protectedFootprintTimePattern);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(resourceType);
+ v(intraPRBProtectedResourceFootprint);
+ v(protectedFootprintFrequencyPattern);
+ v(protectedFootprintTimePattern);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ resourceType.clear();
+ intraPRBProtectedResourceFootprint.clear();
+ protectedFootprintFrequencyPattern.clear();
+ protectedFootprintTimePattern.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ resourceType_t resourceType;
+ intraPRBProtectedResourceFootprint_t intraPRBProtectedResourceFootprint;
+ protectedFootprintFrequencyPattern_t protectedFootprintFrequencyPattern;
+ protectedFootprintTimePattern_t protectedFootprintTimePattern;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ProtectedResourceList ::= SEQUENCE (SIZE(1.. maxnoofProtectedResourcePatterns)) OF ProtectedResourceList-Item
+*/
+
+struct ProtectedResourceList_elm : ProtectedResourceList_Item
+{
+ static constexpr const char* name() {return "ProtectedResourceList_elm";}
+ using parent_t = ProtectedResourceList_Item;
+
+};
+struct ProtectedResourceList : asn::sequenceof<ProtectedResourceList_elm>
+{
+ static constexpr const char* name() {return "ProtectedResourceList";}
+ using parent_t = asn::sequenceof<ProtectedResourceList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofProtectedResourcePatterns >>;
+
+};
+/*
+ProtectedEUTRAResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+} -- Rapporteur: missing extension --
+*/
+
+struct ProtectedEUTRAResourceIndication_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ProtectedEUTRAResourceIndication::= SEQUENCE {
+ activationSFN INTEGER (0..1023),
+ protectedResourceList ProtectedResourceList,
+ mBSFNControlRegionLength INTEGER (0..3) OPTIONAL,
+ pDCCHRegionLength INTEGER (1..3) OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {ProtectedEUTRAResourceIndication-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ProtectedEUTRAResourceIndication : asn::sequence<5, 0, true, 3>
+{
+ static constexpr const char* name() {return "ProtectedEUTRAResourceIndication";}
+ using parent_t = asn::sequence<5, 0, true, 3>;
+ struct activationSFN_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
+ static constexpr const char* name() {return "activationSFN_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ activationSFN_t& ref_activationSFN() {return activationSFN;}
+ activationSFN_t const& ref_activationSFN() const {return activationSFN;}
+ struct protectedResourceList_t : ProtectedResourceList
+ {
+ static constexpr const char* name() {return "protectedResourceList_t";}
+ using parent_t = ProtectedResourceList;
+
+ };
+ protectedResourceList_t& ref_protectedResourceList() {return protectedResourceList;}
+ protectedResourceList_t const& ref_protectedResourceList() const {return protectedResourceList;}
+ struct mBSFNControlRegionLength_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 3>>;
+ static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ mBSFNControlRegionLength_t& set_mBSFNControlRegionLength() { mBSFNControlRegionLength.setpresent(true); return mBSFNControlRegionLength;}
+ mBSFNControlRegionLength_t const* get_mBSFNControlRegionLength() const {return mBSFNControlRegionLength.is_valid() ? &mBSFNControlRegionLength : nullptr;}
+ struct pDCCHRegionLength_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<1, 3>>;
+ static constexpr const char* name() {return "pDCCHRegionLength_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ pDCCHRegionLength_t& set_pDCCHRegionLength() { pDCCHRegionLength.setpresent(true); return pDCCHRegionLength;}
+ pDCCHRegionLength_t const* get_pDCCHRegionLength() const {return pDCCHRegionLength.is_valid() ? &pDCCHRegionLength : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(activationSFN);
+ v(protectedResourceList);
+ v(mBSFNControlRegionLength);
+ v(pDCCHRegionLength);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(activationSFN);
+ v(protectedResourceList);
+ v(mBSFNControlRegionLength);
+ v(pDCCHRegionLength);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ activationSFN.clear();
+ protectedResourceList.clear();
+ mBSFNControlRegionLength.clear();
+ pDCCHRegionLength.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ activationSFN_t activationSFN;
+ protectedResourceList_t protectedResourceList;
+ mBSFNControlRegionLength_t mBSFNControlRegionLength;
+ pDCCHRegionLength_t pDCCHRegionLength;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+Reestablishment-Indication ::= ENUMERATED {
+ reestablished,
+ ...
+}
+*/
+
+struct Reestablishment_Indication : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "Reestablishment-Indication";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ reestablished
+ } index_t;
+
+};
+
+/*
+RLC-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct RLC_Status_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+RLC-Status ::= SEQUENCE {
+ reestablishment-Indication Reestablishment-Indication,
+ iE-Extensions ProtocolExtensionContainer { {RLC-Status-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct RLC_Status : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "RLC-Status";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct reestablishment_Indication_t : Reestablishment_Indication
+ {
+ static constexpr const char* name() {return "reestablishment_Indication_t";}
+ using parent_t = Reestablishment_Indication;
+
+ };
+ reestablishment_Indication_t& ref_reestablishment_Indication() {return reestablishment_Indication;}
+ reestablishment_Indication_t const& ref_reestablishment_Indication() const {return reestablishment_Indication;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<RLC_Status_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<RLC_Status_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(reestablishment_Indication);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(reestablishment_Indication);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ reestablishment_Indication.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ reestablishment_Indication_t reestablishment_Indication;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+RLCMode ::= ENUMERATED {
+ rlc-am,
+ rlc-um-bidirectional,
+ rlc-um-unidirectional-ul,
+ rlc-um-unidirectional-dl,
+ ...
+}
+*/
+
+struct RLCMode : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "RLCMode";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ rlc_am
+ ,rlc_um_bidirectional
+ ,rlc_um_unidirectional_ul
+ ,rlc_um_unidirectional_dl
+ } index_t;
+
+};
+
+/*
+RRC-Config-Ind ::= ENUMERATED {
+ full-config,
+ delta-config,
+ ...
+}
+*/
+
+struct RRC_Config_Ind : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "RRC-Config-Ind";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ full_config
+ ,delta_config
+ } index_t;
+
+};
+
+/*
+RRC-Context ::= OCTET STRING
+*/
+
+struct RRC_Context : asn::ostring<>
+{
+ static constexpr const char* name() {return "RRC-Context";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RRCConnReestabIndicator ::= ENUMERATED {
+ reconfigurationFailure, handoverFailure, otherFailure, ...
+}
+*/
+
+struct RRCConnReestabIndicator : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "RRCConnReestabIndicator";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ reconfigurationFailure
+ ,handoverFailure
+ ,otherFailure
+ } index_t;
+
+};
+
+/*
+RRCConnSetupIndicator::= ENUMERATED {
+ rrcConnSetup,
+ ...
+}
+*/
+
+struct RRCConnSetupIndicator : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "RRCConnSetupIndicator";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ rrcConnSetup
+ } index_t;
+
+};
+
+/*
+RRCContainer ::= OCTET STRING
+*/
+
+struct RRCContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "RRCContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RSRPMeasurementResult-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct RSRPMeasurementResult_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+RSRPMeasurementResult ::= SEQUENCE (SIZE(1..maxCellReport)) OF
+ SEQUENCE {
+ rSRPCellID ECGI,
+ rSRPMeasured INTEGER (0..97, ...),
+ iE-Extensions ProtocolExtensionContainer { {RSRPMeasurementResult-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct RSRPMeasurementResult_elm : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "RSRPMeasurementResult_elm";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct rSRPCellID_t : ECGI
+ {
+ static constexpr const char* name() {return "rSRPCellID_t";}
+ using parent_t = ECGI;
+
+ };
+ rSRPCellID_t& ref_rSRPCellID() {return rSRPCellID;}
+ rSRPCellID_t const& ref_rSRPCellID() const {return rSRPCellID;}
+ struct rSRPMeasured_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 97>>;
+ static constexpr const char* name() {return "rSRPMeasured_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ rSRPMeasured_t& ref_rSRPMeasured() {return rSRPMeasured;}
+ rSRPMeasured_t const& ref_rSRPMeasured() const {return rSRPMeasured;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rSRPCellID);
+ v(rSRPMeasured);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rSRPCellID);
+ v(rSRPMeasured);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rSRPCellID.clear();
+ rSRPMeasured.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rSRPCellID_t rSRPCellID;
+ rSRPMeasured_t rSRPMeasured;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct RSRPMeasurementResult : asn::sequenceof<RSRPMeasurementResult_elm>
+{
+ static constexpr const char* name() {return "RSRPMeasurementResult";}
+ using parent_t = asn::sequenceof<RSRPMeasurementResult_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCellReport >>;
+
+};
+/*
+RSRPMRList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-UEID CRITICALITY ignore EXTENSION UEID PRESENCE optional},
+ ...
+}
+*/
+
+struct RSRPMRList_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_UEID() { set(id_UEID); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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_UEID)) { 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_UEID);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_UEID() { set(ignore); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ UEID& select_id_UEID() { return set<UEID>(1); }
+ UEID const* get_id_UEID() const { return get<UEID>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<UEID>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<UEID>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_UEID()); 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<UEID>()); 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(UEID)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_UEID() { set(optional); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+RSRPMRList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
+ SEQUENCE {
+ rSRPMeasurementResult RSRPMeasurementResult,
+ iE-Extensions ProtocolExtensionContainer { {RSRPMRList-ExtIEs} } OPTIONAL,
+ ...
+ }
+*/
+
+struct RSRPMRList_elm : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "RSRPMRList_elm";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct rSRPMeasurementResult_t : RSRPMeasurementResult
+ {
+ static constexpr const char* name() {return "rSRPMeasurementResult_t";}
+ using parent_t = RSRPMeasurementResult;
+
+ };
+ rSRPMeasurementResult_t& ref_rSRPMeasurementResult() {return rSRPMeasurementResult;}
+ rSRPMeasurementResult_t const& ref_rSRPMeasurementResult() const {return rSRPMeasurementResult;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMRList_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<RSRPMRList_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rSRPMeasurementResult);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rSRPMeasurementResult);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rSRPMeasurementResult.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rSRPMeasurementResult_t rSRPMeasurementResult;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct RSRPMRList : asn::sequenceof<RSRPMRList_elm>
+{
+ static constexpr const char* name() {return "RSRPMRList";}
+ using parent_t = asn::sequenceof<RSRPMRList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxUEReport >>;
+
+};
+/*
+UL-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_GBR_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "UL-GBR-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-non-GBR-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_non_GBR_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "UL-non-GBR-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-Total-PRB-usage::= INTEGER (0..100)
+*/
+
+struct UL_Total_PRB_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "UL-Total-PRB-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
+*/
+
+struct UL_scheduling_PDCCH_CCE_usage : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 100>>;
+ static constexpr const char* name() {return "UL-scheduling-PDCCH-CCE-usage";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+RadioResourceStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ {ID id-DL-scheduling-PDCCH-CCE-usage CRITICALITY ignore EXTENSION DL-scheduling-PDCCH-CCE-usage PRESENCE optional}|
+
+ {ID id-UL-scheduling-PDCCH-CCE-usage CRITICALITY ignore EXTENSION UL-scheduling-PDCCH-CCE-usage PRESENCE optional},
+ ...
+}
+*/
+
+struct RadioResourceStatus_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DL_scheduling_PDCCH_CCE_usage() { set(id_DL_scheduling_PDCCH_CCE_usage); type=1;}
+ void select_id_UL_scheduling_PDCCH_CCE_usage() { set(id_UL_scheduling_PDCCH_CCE_usage); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_DL_scheduling_PDCCH_CCE_usage)) { type = 1; return true; }
+ else if(equal(id_UL_scheduling_PDCCH_CCE_usage)) { 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_DL_scheduling_PDCCH_CCE_usage);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_UL_scheduling_PDCCH_CCE_usage);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DL_scheduling_PDCCH_CCE_usage() { set(ignore); type=1;}
+ void select_id_UL_scheduling_PDCCH_CCE_usage() { set(ignore); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { 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(ignore);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ DL_scheduling_PDCCH_CCE_usage& select_id_DL_scheduling_PDCCH_CCE_usage() { return set<DL_scheduling_PDCCH_CCE_usage>(1); }
+ DL_scheduling_PDCCH_CCE_usage const* get_id_DL_scheduling_PDCCH_CCE_usage() const { return get<DL_scheduling_PDCCH_CCE_usage>(1); }
+ UL_scheduling_PDCCH_CCE_usage& select_id_UL_scheduling_PDCCH_CCE_usage() { return set<UL_scheduling_PDCCH_CCE_usage>(2); }
+ UL_scheduling_PDCCH_CCE_usage const* get_id_UL_scheduling_PDCCH_CCE_usage() const { return get<UL_scheduling_PDCCH_CCE_usage>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<DL_scheduling_PDCCH_CCE_usage>(); break;
+ case 2: var.destroy<UL_scheduling_PDCCH_CCE_usage>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<DL_scheduling_PDCCH_CCE_usage>(1);
+ v.template operator()<UL_scheduling_PDCCH_CCE_usage>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_DL_scheduling_PDCCH_CCE_usage()); return true;
+ case 2: v(select_id_UL_scheduling_PDCCH_CCE_usage()); 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<DL_scheduling_PDCCH_CCE_usage>()); return true;
+ case 2: v(var.as<UL_scheduling_PDCCH_CCE_usage>()); 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(DL_scheduling_PDCCH_CCE_usage)];
+ char dummy2[sizeof(UL_scheduling_PDCCH_CCE_usage)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_DL_scheduling_PDCCH_CCE_usage() { set(optional); type=1;}
+ void select_id_UL_scheduling_PDCCH_CCE_usage() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+RadioResourceStatus ::= SEQUENCE {
+ dL-GBR-PRB-usage DL-GBR-PRB-usage,
+ uL-GBR-PRB-usage UL-GBR-PRB-usage,
+ dL-non-GBR-PRB-usage DL-non-GBR-PRB-usage,
+ uL-non-GBR-PRB-usage UL-non-GBR-PRB-usage,
+ dL-Total-PRB-usage DL-Total-PRB-usage,
+ uL-Total-PRB-usage UL-Total-PRB-usage,
+ iE-Extensions ProtocolExtensionContainer { {RadioResourceStatus-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct RadioResourceStatus : asn::sequence<7, 0, true, 1>
+{
+ static constexpr const char* name() {return "RadioResourceStatus";}
+ using parent_t = asn::sequence<7, 0, true, 1>;
+ struct dL_GBR_PRB_usage_t : DL_GBR_PRB_usage
+ {
+ static constexpr const char* name() {return "dL_GBR_PRB_usage_t";}
+ using parent_t = DL_GBR_PRB_usage;
+
+ };
+ dL_GBR_PRB_usage_t& ref_dL_GBR_PRB_usage() {return dL_GBR_PRB_usage;}
+ dL_GBR_PRB_usage_t const& ref_dL_GBR_PRB_usage() const {return dL_GBR_PRB_usage;}
+ struct uL_GBR_PRB_usage_t : UL_GBR_PRB_usage
+ {
+ static constexpr const char* name() {return "uL_GBR_PRB_usage_t";}
+ using parent_t = UL_GBR_PRB_usage;
+
+ };
+ uL_GBR_PRB_usage_t& ref_uL_GBR_PRB_usage() {return uL_GBR_PRB_usage;}
+ uL_GBR_PRB_usage_t const& ref_uL_GBR_PRB_usage() const {return uL_GBR_PRB_usage;}
+ struct dL_non_GBR_PRB_usage_t : DL_non_GBR_PRB_usage
+ {
+ static constexpr const char* name() {return "dL_non_GBR_PRB_usage_t";}
+ using parent_t = DL_non_GBR_PRB_usage;
+
+ };
+ dL_non_GBR_PRB_usage_t& ref_dL_non_GBR_PRB_usage() {return dL_non_GBR_PRB_usage;}
+ dL_non_GBR_PRB_usage_t const& ref_dL_non_GBR_PRB_usage() const {return dL_non_GBR_PRB_usage;}
+ struct uL_non_GBR_PRB_usage_t : UL_non_GBR_PRB_usage
+ {
+ static constexpr const char* name() {return "uL_non_GBR_PRB_usage_t";}
+ using parent_t = UL_non_GBR_PRB_usage;
+
+ };
+ uL_non_GBR_PRB_usage_t& ref_uL_non_GBR_PRB_usage() {return uL_non_GBR_PRB_usage;}
+ uL_non_GBR_PRB_usage_t const& ref_uL_non_GBR_PRB_usage() const {return uL_non_GBR_PRB_usage;}
+ struct dL_Total_PRB_usage_t : DL_Total_PRB_usage
+ {
+ static constexpr const char* name() {return "dL_Total_PRB_usage_t";}
+ using parent_t = DL_Total_PRB_usage;
+
+ };
+ dL_Total_PRB_usage_t& ref_dL_Total_PRB_usage() {return dL_Total_PRB_usage;}
+ dL_Total_PRB_usage_t const& ref_dL_Total_PRB_usage() const {return dL_Total_PRB_usage;}
+ struct uL_Total_PRB_usage_t : UL_Total_PRB_usage
+ {
+ static constexpr const char* name() {return "uL_Total_PRB_usage_t";}
+ using parent_t = UL_Total_PRB_usage;
+
+ };
+ uL_Total_PRB_usage_t& ref_uL_Total_PRB_usage() {return uL_Total_PRB_usage;}
+ uL_Total_PRB_usage_t const& ref_uL_Total_PRB_usage() const {return uL_Total_PRB_usage;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dL_GBR_PRB_usage);
+ v(uL_GBR_PRB_usage);
+ v(dL_non_GBR_PRB_usage);
+ v(uL_non_GBR_PRB_usage);
+ v(dL_Total_PRB_usage);
+ v(uL_Total_PRB_usage);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dL_GBR_PRB_usage);
+ v(uL_GBR_PRB_usage);
+ v(dL_non_GBR_PRB_usage);
+ v(uL_non_GBR_PRB_usage);
+ v(dL_Total_PRB_usage);
+ v(uL_Total_PRB_usage);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dL_GBR_PRB_usage.clear();
+ uL_GBR_PRB_usage.clear();
+ dL_non_GBR_PRB_usage.clear();
+ uL_non_GBR_PRB_usage.clear();
+ dL_Total_PRB_usage.clear();
+ uL_Total_PRB_usage.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dL_GBR_PRB_usage_t dL_GBR_PRB_usage;
+ uL_GBR_PRB_usage_t uL_GBR_PRB_usage;
+ dL_non_GBR_PRB_usage_t dL_non_GBR_PRB_usage;
+ uL_non_GBR_PRB_usage_t uL_non_GBR_PRB_usage;
+ dL_Total_PRB_usage_t dL_Total_PRB_usage;
+ uL_Total_PRB_usage_t uL_Total_PRB_usage;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ReceiveStatusOfULPDCPSDUsExtended ::= BIT STRING (SIZE(1..16384))
+*/
+
+struct ReceiveStatusOfULPDCPSDUsExtended : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 16384>>;
+ static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsExtended";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 ::= BIT STRING (SIZE(1..131072))
+*/
+
+struct ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 131072>>;
+ static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsPDCP-SNlength18";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReceiveStatusofULPDCPSDUs ::= BIT STRING (SIZE(4096))
+*/
+
+struct ReceiveStatusofULPDCPSDUs : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<4096>>;
+ static constexpr const char* name() {return "ReceiveStatusofULPDCPSDUs";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+Registration-Request ::= ENUMERATED {
+ start,
+ stop,
+ ...,
+ partial-stop,
+ add
+}
+*/
+
+struct Registration_Request : asn::enumerated<4, 2, true>
+{
+ static constexpr const char* name() {return "Registration-Request";}
+ using parent_t = asn::enumerated<4, 2, true>;
+ typedef enum {
+ start
+ ,stop
+ ,partial_stop
+ ,add
+ } index_t;
+
+};
+
+/*
+RelativeNarrowbandTxPower-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-enhancedRNTP CRITICALITY ignore EXTENSION EnhancedRNTP PRESENCE optional },
+ ...
+}
+*/
+
+struct RelativeNarrowbandTxPower_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_enhancedRNTP() { set(id_enhancedRNTP); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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_enhancedRNTP)) { 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_enhancedRNTP);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_enhancedRNTP() { set(ignore); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ EnhancedRNTP& select_id_enhancedRNTP() { return set<EnhancedRNTP>(1); }
+ EnhancedRNTP const* get_id_enhancedRNTP() const { return get<EnhancedRNTP>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<EnhancedRNTP>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<EnhancedRNTP>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_enhancedRNTP()); 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<EnhancedRNTP>()); 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(EnhancedRNTP)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_enhancedRNTP() { set(optional); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+RelativeNarrowbandTxPower ::= SEQUENCE {
+
+ rNTP-PerPRB BIT STRING (SIZE(6..110, ...)),
+ rNTP-Threshold RNTP-Threshold,
+ numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
+ p-B INTEGER (0..3,...),
+ pDCCH-InterferenceImpact INTEGER (0..4,...),
+ iE-Extensions ProtocolExtensionContainer { {RelativeNarrowbandTxPower-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct RelativeNarrowbandTxPower : asn::sequence<6, 0, true, 1>
+{
+ static constexpr const char* name() {return "RelativeNarrowbandTxPower";}
+ using parent_t = asn::sequence<6, 0, true, 1>;
+ struct rNTP_PerPRB_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 110>>;
+ static constexpr const char* name() {return "rNTP_PerPRB_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ rNTP_PerPRB_t& ref_rNTP_PerPRB() {return rNTP_PerPRB;}
+ rNTP_PerPRB_t const& ref_rNTP_PerPRB() const {return rNTP_PerPRB;}
+ struct rNTP_Threshold_t : RNTP_Threshold
+ {
+ static constexpr const char* name() {return "rNTP_Threshold_t";}
+ using parent_t = RNTP_Threshold;
+
+ };
+ rNTP_Threshold_t& ref_rNTP_Threshold() {return rNTP_Threshold;}
+ rNTP_Threshold_t const& ref_rNTP_Threshold() const {return rNTP_Threshold;}
+ struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
+ {
+ static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ one
+ ,two
+ ,four
+ } index_t;
+
+ };
+
+ numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
+ numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
+ struct p_B_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 3>>;
+ static constexpr const char* name() {return "p_B_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ p_B_t& ref_p_B() {return p_B;}
+ p_B_t const& ref_p_B() const {return p_B;}
+ struct pDCCH_InterferenceImpact_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 4>>;
+ static constexpr const char* name() {return "pDCCH_InterferenceImpact_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ pDCCH_InterferenceImpact_t& ref_pDCCH_InterferenceImpact() {return pDCCH_InterferenceImpact;}
+ pDCCH_InterferenceImpact_t const& ref_pDCCH_InterferenceImpact() const {return pDCCH_InterferenceImpact;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rNTP_PerPRB);
+ v(rNTP_Threshold);
+ v(numberOfCellSpecificAntennaPorts);
+ v(p_B);
+ v(pDCCH_InterferenceImpact);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rNTP_PerPRB);
+ v(rNTP_Threshold);
+ v(numberOfCellSpecificAntennaPorts);
+ v(p_B);
+ v(pDCCH_InterferenceImpact);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rNTP_PerPRB.clear();
+ rNTP_Threshold.clear();
+ numberOfCellSpecificAntennaPorts.clear();
+ p_B.clear();
+ pDCCH_InterferenceImpact.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rNTP_PerPRB_t rNTP_PerPRB;
+ rNTP_Threshold_t rNTP_Threshold;
+ numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
+ p_B_t p_B;
+ pDCCH_InterferenceImpact_t pDCCH_InterferenceImpact;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ReportCharacteristics ::= BIT STRING (SIZE (32))
+*/
+
+struct ReportCharacteristics : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<32>>;
+ static constexpr const char* name() {return "ReportCharacteristics";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+ReportingPeriodicityCSIR ::= ENUMERATED {
+ ms5,
+ ms10,
+ ms20,
+ ms40,
+ ms80,
+...
+}
+*/
+
+struct ReportingPeriodicityCSIR : asn::enumerated<5, 0, true>
+{
+ static constexpr const char* name() {return "ReportingPeriodicityCSIR";}
+ using parent_t = asn::enumerated<5, 0, true>;
+ typedef enum {
+ ms5
+ ,ms10
+ ,ms20
+ ,ms40
+ ,ms80
+ } index_t;
+
+};
+
+/*
+ReportingPeriodicityRSRPMR ::= ENUMERATED {
+ one-hundred-20-ms,
+ two-hundred-40-ms,
+ four-hundred-80-ms,
+ six-hundred-40-ms,
+...
+}
+*/
+
+struct ReportingPeriodicityRSRPMR : asn::enumerated<4, 0, true>
+{
+ static constexpr const char* name() {return "ReportingPeriodicityRSRPMR";}
+ using parent_t = asn::enumerated<4, 0, true>;
+ typedef enum {
+ one_hundred_20_ms
+ ,two_hundred_40_ms
+ ,four_hundred_80_ms
+ ,six_hundred_40_ms
+ } index_t;
+
+};
+
+/*
+ResumeID ::= CHOICE {
+ non-truncated BIT STRING(SIZE(40)),
+ truncated BIT STRING(SIZE(24)),
+ ...
+}
+*/
+
+struct ResumeID : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "ResumeID";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~ResumeID() {clear();}
+ struct non_truncated_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<40>>;
+ static constexpr const char* name() {return "non_truncated_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ struct truncated_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<24>>;
+ static constexpr const char* name() {return "truncated_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<non_truncated_t>(); break;
+ case 2: var.destroy<truncated_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<non_truncated_t>());
+ case 2: set_index(2); return v(var.build<truncated_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<non_truncated_t>());
+ case 2: return v(var.as<truncated_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<non_truncated_t>(1);
+ v.template operator()<truncated_t>(2);
+
+ }
+ non_truncated_t& select_non_truncated() { if(get_index() != 1) { clear(); set_index(1); return var.build<non_truncated_t>();} return var.as<non_truncated_t>();}
+ non_truncated_t const* get_non_truncated() const { if(get_index() == 1) { return &var.as<non_truncated_t>();} return nullptr; }
+ truncated_t& select_truncated() { if(get_index() != 2) { clear(); set_index(2); return var.build<truncated_t>();} return var.as<truncated_t>();}
+ truncated_t const* get_truncated() const { if(get_index() == 2) { return &var.as<truncated_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(non_truncated_t)];
+ char dummy2[sizeof(truncated_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+S1TNLLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct S1TNLLoadIndicator_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+S1TNLLoadIndicator ::= SEQUENCE {
+ dLS1TNLLoadIndicator LoadIndicator,
+ uLS1TNLLoadIndicator LoadIndicator,
+ iE-Extensions ProtocolExtensionContainer { {S1TNLLoadIndicator-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct S1TNLLoadIndicator : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "S1TNLLoadIndicator";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct dLS1TNLLoadIndicator_t : LoadIndicator
+ {
+ static constexpr const char* name() {return "dLS1TNLLoadIndicator_t";}
+ using parent_t = LoadIndicator;
+
+ };
+ dLS1TNLLoadIndicator_t& ref_dLS1TNLLoadIndicator() {return dLS1TNLLoadIndicator;}
+ dLS1TNLLoadIndicator_t const& ref_dLS1TNLLoadIndicator() const {return dLS1TNLLoadIndicator;}
+ struct uLS1TNLLoadIndicator_t : LoadIndicator
+ {
+ static constexpr const char* name() {return "uLS1TNLLoadIndicator_t";}
+ using parent_t = LoadIndicator;
+
+ };
+ uLS1TNLLoadIndicator_t& ref_uLS1TNLLoadIndicator() {return uLS1TNLLoadIndicator;}
+ uLS1TNLLoadIndicator_t const& ref_uLS1TNLLoadIndicator() const {return uLS1TNLLoadIndicator;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dLS1TNLLoadIndicator);
+ v(uLS1TNLLoadIndicator);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dLS1TNLLoadIndicator);
+ v(uLS1TNLLoadIndicator);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dLS1TNLLoadIndicator.clear();
+ uLS1TNLLoadIndicator.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dLS1TNLLoadIndicator_t dLS1TNLLoadIndicator;
+ uLS1TNLLoadIndicator_t uLS1TNLLoadIndicator;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SCGChangeIndication ::= ENUMERATED {pDCPCountWrapAround, pSCellChange, other, ...}
+*/
+
+struct SCGChangeIndication : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "SCGChangeIndication";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ pDCPCountWrapAround
+ ,pSCellChange
+ ,other
+ } index_t;
+
+};
+
+/*
+SCGConfigurationQuery ::= ENUMERATED {true,...}
+*/
+
+struct SCGConfigurationQuery : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "SCGConfigurationQuery";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ True
+ } index_t;
+
+};
+
+/*
+SGNB-Addition-Trigger-Ind ::= ENUMERATED {
+ sn-change,
+ inter-eNB-HO,
+ intra-eNB-HO,
+ ...
+}
+*/
+
+struct SGNB_Addition_Trigger_Ind : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "SGNB-Addition-Trigger-Ind";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ sn_change
+ ,inter_eNB_HO
+ ,intra_eNB_HO
+ } index_t;
+
+};
+
+/*
+SIPTOBearerDeactivationIndication ::= ENUMERATED {
+ true,
+ ...
+}
+*/
+
+struct SIPTOBearerDeactivationIndication : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "SIPTOBearerDeactivationIndication";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ True
+ } index_t;
+
+};
+
+/*
+SRBType ::= ENUMERATED {srb1, srb2, ...}
+*/
+
+struct SRBType : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "SRBType";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ srb1
+ ,srb2
+ } index_t;
+
+};
+
+/*
+SRVCCOperationPossible ::= ENUMERATED {
+ possible,
+ ...
+}
+*/
+
+struct SRVCCOperationPossible : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "SRVCCOperationPossible";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ possible
+ } index_t;
+
+};
+
+/*
+ScheduledCommunicationTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ScheduledCommunicationTime_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ScheduledCommunicationTime ::= SEQUENCE {
+ dayofWeek BIT STRING (SIZE(7)) OPTIONAL,
+ timeofDayStart INTEGER (0..86399, ...) OPTIONAL,
+ timeofDayEnd INTEGER (0..86399, ...) OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { { ScheduledCommunicationTime-ExtIEs}} OPTIONAL,
+ ...
+}
+*/
+
+struct ScheduledCommunicationTime : asn::sequence<4, 0, true, 4>
+{
+ static constexpr const char* name() {return "ScheduledCommunicationTime";}
+ using parent_t = asn::sequence<4, 0, true, 4>;
+ struct dayofWeek_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<7>>;
+ static constexpr const char* name() {return "dayofWeek_t";}
+ using parent_t = asn::bstring<>;
+ static constexpr bool optional = true;
+
+ };
+
+ dayofWeek_t& set_dayofWeek() { dayofWeek.setpresent(true); return dayofWeek;}
+ dayofWeek_t const* get_dayofWeek() const {return dayofWeek.is_valid() ? &dayofWeek : nullptr;}
+ struct timeofDayStart_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
+ static constexpr const char* name() {return "timeofDayStart_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ timeofDayStart_t& set_timeofDayStart() { timeofDayStart.setpresent(true); return timeofDayStart;}
+ timeofDayStart_t const* get_timeofDayStart() const {return timeofDayStart.is_valid() ? &timeofDayStart : nullptr;}
+ struct timeofDayEnd_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
+ static constexpr const char* name() {return "timeofDayEnd_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ timeofDayEnd_t& set_timeofDayEnd() { timeofDayEnd.setpresent(true); return timeofDayEnd;}
+ timeofDayEnd_t const* get_timeofDayEnd() const {return timeofDayEnd.is_valid() ? &timeofDayEnd : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(dayofWeek);
+ v(timeofDayStart);
+ v(timeofDayEnd);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(dayofWeek);
+ v(timeofDayStart);
+ v(timeofDayEnd);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ dayofWeek.clear();
+ timeofDayStart.clear();
+ timeofDayEnd.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ dayofWeek_t dayofWeek;
+ timeofDayStart_t timeofDayStart;
+ timeofDayEnd_t timeofDayEnd;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SeNBSecurityKey ::= BIT STRING (SIZE(256))
+*/
+
+struct SeNBSecurityKey : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<256>>;
+ static constexpr const char* name() {return "SeNBSecurityKey";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+SeNBtoMeNBContainer ::= OCTET STRING
+*/
+
+struct SeNBtoMeNBContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "SeNBtoMeNBContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+SecondaryRATUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SecondaryRATUsageReport_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SecondaryRATUsageReport-Item ::= SEQUENCE {
+ e-RAB-ID E-RAB-ID,
+ secondaryRATType ENUMERATED {nr, ...},
+ e-RABUsageReportList E-RABUsageReportList,
+ iE-Extensions ProtocolExtensionContainer { {SecondaryRATUsageReport-Item-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct SecondaryRATUsageReport_Item : asn::sequence<4, 0, true, 1>
+{
+ static constexpr const char* name() {return "SecondaryRATUsageReport-Item";}
+ using parent_t = asn::sequence<4, 0, true, 1>;
+ struct e_RAB_ID_t : E_RAB_ID
+ {
+ static constexpr const char* name() {return "e_RAB_ID_t";}
+ using parent_t = E_RAB_ID;
+
+ };
+ e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
+ e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
+ struct secondaryRATType_t : asn::enumerated<1, 0, true>
+ {
+ static constexpr const char* name() {return "secondaryRATType_t";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ nr
+ } index_t;
+
+ };
+
+ secondaryRATType_t& ref_secondaryRATType() {return secondaryRATType;}
+ secondaryRATType_t const& ref_secondaryRATType() const {return secondaryRATType;}
+ struct e_RABUsageReportList_t : E_RABUsageReportList
+ {
+ static constexpr const char* name() {return "e_RABUsageReportList_t";}
+ using parent_t = E_RABUsageReportList;
+
+ };
+ e_RABUsageReportList_t& ref_e_RABUsageReportList() {return e_RABUsageReportList;}
+ e_RABUsageReportList_t const& ref_e_RABUsageReportList() const {return e_RABUsageReportList;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(e_RAB_ID);
+ v(secondaryRATType);
+ v(e_RABUsageReportList);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(e_RAB_ID);
+ v(secondaryRATType);
+ v(e_RABUsageReportList);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ e_RAB_ID.clear();
+ secondaryRATType.clear();
+ e_RABUsageReportList.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ e_RAB_ID_t e_RAB_ID;
+ secondaryRATType_t secondaryRATType;
+ e_RABUsageReportList_t e_RABUsageReportList;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SecondaryRATUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
+ { ID id-SecondaryRATUsageReport-Item CRITICALITY reject TYPE SecondaryRATUsageReport-Item PRESENCE mandatory},
+ ...
+}
+*/
+
+struct SecondaryRATUsageReport_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_SecondaryRATUsageReport_Item() { set(id_SecondaryRATUsageReport_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_SecondaryRATUsageReport_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_SecondaryRATUsageReport_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_SecondaryRATUsageReport_Item() { 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;}
+ SecondaryRATUsageReport_Item& select_id_SecondaryRATUsageReport_Item() { return set<SecondaryRATUsageReport_Item>(1); }
+ SecondaryRATUsageReport_Item const* get_id_SecondaryRATUsageReport_Item() const { return get<SecondaryRATUsageReport_Item>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<SecondaryRATUsageReport_Item>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<SecondaryRATUsageReport_Item>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_SecondaryRATUsageReport_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<SecondaryRATUsageReport_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(SecondaryRATUsageReport_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_SecondaryRATUsageReport_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};
+
+ };
+
+};
+/*
+SecondaryRATUsageReportList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container {{SecondaryRATUsageReport-ItemIEs}}
+*/
+
+struct SecondaryRATUsageReportList_elm : ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>
+{
+ static constexpr const char* name() {return "SecondaryRATUsageReportList_elm";}
+ using parent_t = ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>;
+
+};
+struct SecondaryRATUsageReportList : asn::sequenceof<SecondaryRATUsageReportList_elm>
+{
+ static constexpr const char* name() {return "SecondaryRATUsageReportList";}
+ using parent_t = asn::sequenceof<SecondaryRATUsageReportList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
+
+};
+/*
+ServedCell-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ServedCell_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ServedCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-Number-of-Antennaports CRITICALITY ignore EXTENSION Number-of-Antennaports PRESENCE optional}|
+ { ID id-PRACH-Configuration CRITICALITY ignore EXTENSION PRACH-Configuration PRESENCE optional}|
+ { ID id-MBSFN-Subframe-Info CRITICALITY ignore EXTENSION MBSFN-Subframe-Infolist PRESENCE optional}|
+ { ID id-CSG-Id CRITICALITY ignore EXTENSION CSG-Id PRESENCE optional}|
+ { ID id-MBMS-Service-Area-List CRITICALITY ignore EXTENSION MBMS-Service-Area-Identity-List PRESENCE optional}|
+ { ID id-MultibandInfoList CRITICALITY ignore EXTENSION MultibandInfoList PRESENCE optional}|
+ { ID id-FreqBandIndicatorPriority CRITICALITY ignore EXTENSION FreqBandIndicatorPriority PRESENCE optional}|
+ { ID id-BandwidthReducedSI CRITICALITY ignore EXTENSION BandwidthReducedSI PRESENCE optional}|
+ { ID id-ProtectedEUTRAResourceIndication CRITICALITY ignore EXTENSION ProtectedEUTRAResourceIndication PRESENCE optional},
+ ...
+}
+*/
+
+struct ServedCell_Information_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_Number_of_Antennaports() { set(id_Number_of_Antennaports); type=1;}
+ void select_id_PRACH_Configuration() { set(id_PRACH_Configuration); type=2;}
+ void select_id_MBSFN_Subframe_Info() { set(id_MBSFN_Subframe_Info); type=3;}
+ void select_id_CSG_Id() { set(id_CSG_Id); type=4;}
+ void select_id_MBMS_Service_Area_List() { set(id_MBMS_Service_Area_List); type=5;}
+ void select_id_MultibandInfoList() { set(id_MultibandInfoList); type=6;}
+ void select_id_FreqBandIndicatorPriority() { set(id_FreqBandIndicatorPriority); type=7;}
+ void select_id_BandwidthReducedSI() { set(id_BandwidthReducedSI); type=8;}
+ void select_id_ProtectedEUTRAResourceIndication() { set(id_ProtectedEUTRAResourceIndication); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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_Number_of_Antennaports)) { type = 1; return true; }
+ else if(equal(id_PRACH_Configuration)) { type = 2; return true; }
+ else if(equal(id_MBSFN_Subframe_Info)) { type = 3; return true; }
+ else if(equal(id_CSG_Id)) { type = 4; return true; }
+ else if(equal(id_MBMS_Service_Area_List)) { type = 5; return true; }
+ else if(equal(id_MultibandInfoList)) { type = 6; return true; }
+ else if(equal(id_FreqBandIndicatorPriority)) { type = 7; return true; }
+ else if(equal(id_BandwidthReducedSI)) { type = 8; return true; }
+ else if(equal(id_ProtectedEUTRAResourceIndication)) { type = 9; return true; }
+ else { type = 10; 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_Number_of_Antennaports);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_PRACH_Configuration);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_MBSFN_Subframe_Info);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(id_CSG_Id);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(id_MBMS_Service_Area_List);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(id_MultibandInfoList);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(id_FreqBandIndicatorPriority);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(id_BandwidthReducedSI);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(id_ProtectedEUTRAResourceIndication);} return false;
+ case 10: type = 10; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_Number_of_Antennaports() { set(ignore); type=1;}
+ void select_id_PRACH_Configuration() { set(ignore); type=2;}
+ void select_id_MBSFN_Subframe_Info() { set(ignore); type=3;}
+ void select_id_CSG_Id() { set(ignore); type=4;}
+ void select_id_MBMS_Service_Area_List() { set(ignore); type=5;}
+ void select_id_MultibandInfoList() { set(ignore); type=6;}
+ void select_id_FreqBandIndicatorPriority() { set(ignore); type=7;}
+ void select_id_BandwidthReducedSI() { set(ignore); type=8;}
+ void select_id_ProtectedEUTRAResourceIndication() { set(ignore); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { type = 2; return true; }
+ else if(equal(ignore)) { type = 3; return true; }
+ else if(equal(ignore)) { type = 4; return true; }
+ else if(equal(ignore)) { type = 5; return true; }
+ else if(equal(ignore)) { type = 6; return true; }
+ else if(equal(ignore)) { type = 7; return true; }
+ else if(equal(ignore)) { type = 8; return true; }
+ else if(equal(ignore)) { type = 9; return true; }
+ else { type = 10; 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; 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; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 10: type = 10; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ Number_of_Antennaports& select_id_Number_of_Antennaports() { return set<Number_of_Antennaports>(1); }
+ Number_of_Antennaports const* get_id_Number_of_Antennaports() const { return get<Number_of_Antennaports>(1); }
+ PRACH_Configuration& select_id_PRACH_Configuration() { return set<PRACH_Configuration>(2); }
+ PRACH_Configuration const* get_id_PRACH_Configuration() const { return get<PRACH_Configuration>(2); }
+ MBSFN_Subframe_Infolist& select_id_MBSFN_Subframe_Info() { return set<MBSFN_Subframe_Infolist>(3); }
+ MBSFN_Subframe_Infolist const* get_id_MBSFN_Subframe_Info() const { return get<MBSFN_Subframe_Infolist>(3); }
+ CSG_Id& select_id_CSG_Id() { return set<CSG_Id>(4); }
+ CSG_Id const* get_id_CSG_Id() const { return get<CSG_Id>(4); }
+ MBMS_Service_Area_Identity_List& select_id_MBMS_Service_Area_List() { return set<MBMS_Service_Area_Identity_List>(5); }
+ MBMS_Service_Area_Identity_List const* get_id_MBMS_Service_Area_List() const { return get<MBMS_Service_Area_Identity_List>(5); }
+ MultibandInfoList& select_id_MultibandInfoList() { return set<MultibandInfoList>(6); }
+ MultibandInfoList const* get_id_MultibandInfoList() const { return get<MultibandInfoList>(6); }
+ FreqBandIndicatorPriority& select_id_FreqBandIndicatorPriority() { return set<FreqBandIndicatorPriority>(7); }
+ FreqBandIndicatorPriority const* get_id_FreqBandIndicatorPriority() const { return get<FreqBandIndicatorPriority>(7); }
+ BandwidthReducedSI& select_id_BandwidthReducedSI() { return set<BandwidthReducedSI>(8); }
+ BandwidthReducedSI const* get_id_BandwidthReducedSI() const { return get<BandwidthReducedSI>(8); }
+ ProtectedEUTRAResourceIndication& select_id_ProtectedEUTRAResourceIndication() { return set<ProtectedEUTRAResourceIndication>(9); }
+ ProtectedEUTRAResourceIndication const* get_id_ProtectedEUTRAResourceIndication() const { return get<ProtectedEUTRAResourceIndication>(9); }
+ bool is_unknown() const { return type == 10; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<Number_of_Antennaports>(); break;
+ case 2: var.destroy<PRACH_Configuration>(); break;
+ case 3: var.destroy<MBSFN_Subframe_Infolist>(); break;
+ case 4: var.destroy<CSG_Id>(); break;
+ case 5: var.destroy<MBMS_Service_Area_Identity_List>(); break;
+ case 6: var.destroy<MultibandInfoList>(); break;
+ case 7: var.destroy<FreqBandIndicatorPriority>(); break;
+ case 8: var.destroy<BandwidthReducedSI>(); break;
+ case 9: var.destroy<ProtectedEUTRAResourceIndication>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<Number_of_Antennaports>(1);
+ v.template operator()<PRACH_Configuration>(2);
+ v.template operator()<MBSFN_Subframe_Infolist>(3);
+ v.template operator()<CSG_Id>(4);
+ v.template operator()<MBMS_Service_Area_Identity_List>(5);
+ v.template operator()<MultibandInfoList>(6);
+ v.template operator()<FreqBandIndicatorPriority>(7);
+ v.template operator()<BandwidthReducedSI>(8);
+ v.template operator()<ProtectedEUTRAResourceIndication>(9);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_Number_of_Antennaports()); return true;
+ case 2: v(select_id_PRACH_Configuration()); return true;
+ case 3: v(select_id_MBSFN_Subframe_Info()); return true;
+ case 4: v(select_id_CSG_Id()); return true;
+ case 5: v(select_id_MBMS_Service_Area_List()); return true;
+ case 6: v(select_id_MultibandInfoList()); return true;
+ case 7: v(select_id_FreqBandIndicatorPriority()); return true;
+ case 8: v(select_id_BandwidthReducedSI()); return true;
+ case 9: v(select_id_ProtectedEUTRAResourceIndication()); return true;
+ case 10: if(type != 10) {clear(); asn::base::set();} type = 10; 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<Number_of_Antennaports>()); return true;
+ case 2: v(var.as<PRACH_Configuration>()); return true;
+ case 3: v(var.as<MBSFN_Subframe_Infolist>()); return true;
+ case 4: v(var.as<CSG_Id>()); return true;
+ case 5: v(var.as<MBMS_Service_Area_Identity_List>()); return true;
+ case 6: v(var.as<MultibandInfoList>()); return true;
+ case 7: v(var.as<FreqBandIndicatorPriority>()); return true;
+ case 8: v(var.as<BandwidthReducedSI>()); return true;
+ case 9: v(var.as<ProtectedEUTRAResourceIndication>()); 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(BandwidthReducedSI)];
+ char dummy2[sizeof(CSG_Id)];
+ char dummy3[sizeof(FreqBandIndicatorPriority)];
+ char dummy4[sizeof(MBMS_Service_Area_Identity_List)];
+ char dummy5[sizeof(MBSFN_Subframe_Infolist)];
+ char dummy6[sizeof(MultibandInfoList)];
+ char dummy7[sizeof(Number_of_Antennaports)];
+ char dummy8[sizeof(PRACH_Configuration)];
+ char dummy9[sizeof(ProtectedEUTRAResourceIndication)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 10; }
+ void clear() {type = 0;}
+ void select_id_Number_of_Antennaports() { set(optional); type=1;}
+ void select_id_PRACH_Configuration() { set(optional); type=2;}
+ void select_id_MBSFN_Subframe_Info() { set(optional); type=3;}
+ void select_id_CSG_Id() { set(optional); type=4;}
+ void select_id_MBMS_Service_Area_List() { set(optional); type=5;}
+ void select_id_MultibandInfoList() { set(optional); type=6;}
+ void select_id_FreqBandIndicatorPriority() { set(optional); type=7;}
+ void select_id_BandwidthReducedSI() { set(optional); type=8;}
+ void select_id_ProtectedEUTRAResourceIndication() { set(optional); type=9;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(optional)) { type = 4; return true; }
+ else if(equal(optional)) { type = 5; return true; }
+ else if(equal(optional)) { type = 6; return true; }
+ else if(equal(optional)) { type = 7; return true; }
+ else if(equal(optional)) { type = 8; return true; }
+ else if(equal(optional)) { type = 9; return true; }
+ else { type = 10; 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; if(v(ref_nested())) { return equal(optional);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
+ case 10: type = 10; 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};
+
+ };
+
+};
+/*
+ServedCell-Information ::= SEQUENCE {
+ pCI PCI,
+ cellId ECGI,
+ tAC TAC,
+ broadcastPLMNs BroadcastPLMNs-Item,
+ eUTRA-Mode-Info EUTRA-Mode-Info,
+ iE-Extensions ProtocolExtensionContainer { {ServedCell-Information-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ServedCell_Information : asn::sequence<6, 0, true, 1>
+{
+ static constexpr const char* name() {return "ServedCell-Information";}
+ using parent_t = asn::sequence<6, 0, true, 1>;
+ struct pCI_t : PCI
+ {
+ static constexpr const char* name() {return "pCI_t";}
+ using parent_t = PCI;
+
+ };
+ pCI_t& ref_pCI() {return pCI;}
+ pCI_t const& ref_pCI() const {return pCI;}
+ struct cellId_t : ECGI
+ {
+ static constexpr const char* name() {return "cellId_t";}
+ using parent_t = ECGI;
+
+ };
+ cellId_t& ref_cellId() {return cellId;}
+ cellId_t const& ref_cellId() const {return cellId;}
+ struct tAC_t : TAC
+ {
+ static constexpr const char* name() {return "tAC_t";}
+ using parent_t = TAC;
+
+ };
+ tAC_t& ref_tAC() {return tAC;}
+ tAC_t const& ref_tAC() const {return tAC;}
+ struct broadcastPLMNs_t : BroadcastPLMNs_Item
+ {
+ static constexpr const char* name() {return "broadcastPLMNs_t";}
+ using parent_t = BroadcastPLMNs_Item;
+
+ };
+ broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
+ broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
+ struct eUTRA_Mode_Info_t : EUTRA_Mode_Info
+ {
+ static constexpr const char* name() {return "eUTRA_Mode_Info_t";}
+ using parent_t = EUTRA_Mode_Info;
+
+ };
+ eUTRA_Mode_Info_t& ref_eUTRA_Mode_Info() {return eUTRA_Mode_Info;}
+ eUTRA_Mode_Info_t const& ref_eUTRA_Mode_Info() const {return eUTRA_Mode_Info;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_Information_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ServedCell_Information_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(pCI);
+ v(cellId);
+ v(tAC);
+ v(broadcastPLMNs);
+ v(eUTRA_Mode_Info);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pCI);
+ v(cellId);
+ v(tAC);
+ v(broadcastPLMNs);
+ v(eUTRA_Mode_Info);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ pCI.clear();
+ cellId.clear();
+ tAC.clear();
+ broadcastPLMNs.clear();
+ eUTRA_Mode_Info.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ pCI_t pCI;
+ cellId_t cellId;
+ tAC_t tAC;
+ broadcastPLMNs_t broadcastPLMNs;
+ eUTRA_Mode_Info_t eUTRA_Mode_Info;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+ServedCells ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
+ servedCellInfo ServedCell-Information,
+ neighbour-Info Neighbour-Information OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {ServedCell-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ServedCells_elm : asn::sequence<3, 0, true, 2>
+{
+ static constexpr const char* name() {return "ServedCells_elm";}
+ using parent_t = asn::sequence<3, 0, true, 2>;
+ struct servedCellInfo_t : ServedCell_Information
+ {
+ static constexpr const char* name() {return "servedCellInfo_t";}
+ using parent_t = ServedCell_Information;
+
+ };
+ servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
+ servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
+ struct neighbour_Info_t : Neighbour_Information
+ {
+ static constexpr const char* name() {return "neighbour_Info_t";}
+ using parent_t = Neighbour_Information;
+ static constexpr bool optional = true;
+
+ };
+ neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
+ neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ServedCell_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(servedCellInfo);
+ v(neighbour_Info);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(servedCellInfo);
+ v(neighbour_Info);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ servedCellInfo.clear();
+ neighbour_Info.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ servedCellInfo_t servedCellInfo;
+ neighbour_Info_t neighbour_Info;
+ iE_Extensions_t iE_Extensions;
+
+};
+struct ServedCells : asn::sequenceof<ServedCells_elm>
+{
+ static constexpr const char* name() {return "ServedCells";}
+ using parent_t = asn::sequenceof<ServedCells_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
+
+};
+/*
+ServiceType ::= ENUMERATED{
+ qMC-for-streaming-service,
+ qMC-for-MTSI-service,
+ ...
+}
+*/
+
+struct ServiceType : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "ServiceType";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ qMC_for_streaming_service
+ ,qMC_for_MTSI_service
+ } index_t;
+
+};
+
+/*
+SgNB-UE-X2AP-ID ::= INTEGER (0..4294967295)
+*/
+
+struct SgNB_UE_X2AP_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+ static constexpr const char* name() {return "SgNB-UE-X2AP-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+SgNBCoordinationAssistanceInformation ::= ENUMERATED{
+ coordination-not-required,
+ ...
+}
+*/
+
+struct SgNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "SgNBCoordinationAssistanceInformation";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ coordination_not_required
+ } index_t;
+
+};
+
+/*
+SgNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-ECGI CRITICALITY ignore EXTENSION ECGI PRESENCE optional}|
+ { ID id-SgNBCoordinationAssistanceInformation CRITICALITY reject EXTENSION SgNBCoordinationAssistanceInformation PRESENCE optional},
+ ...
+}
+*/
+
+struct SgNBResourceCoordinationInformationExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_ECGI() { set(id_ECGI); type=1;}
+ void select_id_SgNBCoordinationAssistanceInformation() { set(id_SgNBCoordinationAssistanceInformation); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_ECGI)) { type = 1; return true; }
+ else if(equal(id_SgNBCoordinationAssistanceInformation)) { 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_ECGI);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNBCoordinationAssistanceInformation);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_ECGI() { set(ignore); type=1;}
+ void select_id_SgNBCoordinationAssistanceInformation() { set(reject); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 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(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ ECGI& select_id_ECGI() { return set<ECGI>(1); }
+ ECGI const* get_id_ECGI() const { return get<ECGI>(1); }
+ SgNBCoordinationAssistanceInformation& select_id_SgNBCoordinationAssistanceInformation() { return set<SgNBCoordinationAssistanceInformation>(2); }
+ SgNBCoordinationAssistanceInformation const* get_id_SgNBCoordinationAssistanceInformation() const { return get<SgNBCoordinationAssistanceInformation>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<ECGI>(); break;
+ case 2: var.destroy<SgNBCoordinationAssistanceInformation>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<ECGI>(1);
+ v.template operator()<SgNBCoordinationAssistanceInformation>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_ECGI()); return true;
+ case 2: v(select_id_SgNBCoordinationAssistanceInformation()); 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<ECGI>()); return true;
+ case 2: v(var.as<SgNBCoordinationAssistanceInformation>()); 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(ECGI)];
+ char dummy2[sizeof(SgNBCoordinationAssistanceInformation)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_ECGI() { set(optional); type=1;}
+ void select_id_SgNBCoordinationAssistanceInformation() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+SgNBResourceCoordinationInformation ::= SEQUENCE {
+ nR-CGI NRCGI,
+ uLCoordinationInformation BIT STRING (SIZE(6..4400, ...)),
+ dLCoordinationInformation BIT STRING (SIZE(6..4400, ...)) OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {SgNBResourceCoordinationInformationExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SgNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
+{
+ static constexpr const char* name() {return "SgNBResourceCoordinationInformation";}
+ using parent_t = asn::sequence<4, 0, true, 2>;
+ struct nR_CGI_t : NRCGI
+ {
+ static constexpr const char* name() {return "nR_CGI_t";}
+ using parent_t = NRCGI;
+
+ };
+ nR_CGI_t& ref_nR_CGI() {return nR_CGI;}
+ nR_CGI_t const& ref_nR_CGI() const {return nR_CGI;}
+ struct uLCoordinationInformation_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+ static constexpr const char* name() {return "uLCoordinationInformation_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
+ uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
+ struct dLCoordinationInformation_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
+ static constexpr const char* name() {return "dLCoordinationInformation_t";}
+ using parent_t = asn::bstring<>;
+ static constexpr bool optional = true;
+
+ };
+
+ dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
+ dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(nR_CGI);
+ v(uLCoordinationInformation);
+ v(dLCoordinationInformation);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(nR_CGI);
+ v(uLCoordinationInformation);
+ v(dLCoordinationInformation);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ nR_CGI.clear();
+ uLCoordinationInformation.clear();
+ dLCoordinationInformation.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ nR_CGI_t nR_CGI;
+ uLCoordinationInformation_t uLCoordinationInformation;
+ dLCoordinationInformation_t dLCoordinationInformation;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SgNBSecurityKey ::= BIT STRING (SIZE(256))
+*/
+
+struct SgNBSecurityKey : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<256>>;
+ static constexpr const char* name() {return "SgNBSecurityKey";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+SgNBtoMeNBContainer ::= OCTET STRING
+*/
+
+struct SgNBtoMeNBContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "SgNBtoMeNBContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+ShortMAC-I ::= BIT STRING (SIZE(16))
+*/
+
+struct ShortMAC_I : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<16>>;
+ static constexpr const char* name() {return "ShortMAC-I";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+SpectrumSharingGroupID ::= INTEGER (1..maxCellineNB)
+*/
+
+struct SpectrumSharingGroupID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
+ static constexpr const char* name() {return "SpectrumSharingGroupID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+SplitSRB-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct SplitSRB_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+SplitSRB ::= SEQUENCE {
+ rrcContainer RRCContainer OPTIONAL,
+ srbType SRBType,
+ deliveryStatus DeliveryStatus OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {SplitSRB-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct SplitSRB : asn::sequence<4, 0, true, 3>
+{
+ static constexpr const char* name() {return "SplitSRB";}
+ using parent_t = asn::sequence<4, 0, true, 3>;
+ struct rrcContainer_t : RRCContainer
+ {
+ static constexpr const char* name() {return "rrcContainer_t";}
+ using parent_t = RRCContainer;
+ static constexpr bool optional = true;
+
+ };
+ rrcContainer_t& set_rrcContainer() { rrcContainer.setpresent(true); return rrcContainer;}
+ rrcContainer_t const* get_rrcContainer() const {return rrcContainer.is_valid() ? &rrcContainer : nullptr;}
+ struct srbType_t : SRBType
+ {
+ static constexpr const char* name() {return "srbType_t";}
+ using parent_t = SRBType;
+
+ };
+ srbType_t& ref_srbType() {return srbType;}
+ srbType_t const& ref_srbType() const {return srbType;}
+ struct deliveryStatus_t : DeliveryStatus
+ {
+ static constexpr const char* name() {return "deliveryStatus_t";}
+ using parent_t = DeliveryStatus;
+ static constexpr bool optional = true;
+
+ };
+ deliveryStatus_t& set_deliveryStatus() { deliveryStatus.setpresent(true); return deliveryStatus;}
+ deliveryStatus_t const* get_deliveryStatus() const {return deliveryStatus.is_valid() ? &deliveryStatus : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<SplitSRB_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<SplitSRB_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(rrcContainer);
+ v(srbType);
+ v(deliveryStatus);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(rrcContainer);
+ v(srbType);
+ v(deliveryStatus);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ rrcContainer.clear();
+ srbType.clear();
+ deliveryStatus.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ rrcContainer_t rrcContainer;
+ srbType_t srbType;
+ deliveryStatus_t deliveryStatus;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+SplitSRBs ::= ENUMERATED {srb1, srb2, srb1and2, ...}
+*/
+
+struct SplitSRBs : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "SplitSRBs";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ srb1
+ ,srb2
+ ,srb1and2
+ } index_t;
+
+};
+
+/*
+SubscriberProfileIDforRFP ::= INTEGER (1..256)
+*/
+
+struct SubscriberProfileIDforRFP : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<1, 256>>;
+ static constexpr const char* name() {return "SubscriberProfileIDforRFP";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+Subscription-Based-UE-DifferentiationInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct Subscription_Based_UE_DifferentiationInfo_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+Subscription-Based-UE-DifferentiationInfo ::= SEQUENCE {
+ periodicCommunicationIndicator ENUMERATED {periodically, ondemand, ...} OPTIONAL,
+ periodicTime INTEGER (1..3600, ...) OPTIONAL,
+ scheduledCommunicationTime ScheduledCommunicationTime OPTIONAL,
+ stationaryIndication ENUMERATED {stationary, mobile, ...} OPTIONAL,
+ trafficProfile ENUMERATED {single-packet, dual-packets, multiple-packets, ...} OPTIONAL,
+ batteryIndication ENUMERATED {battery-powered, battery-powered-not-rechargeable-or-replaceable, not-battery-powered, ...} OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { { Subscription-Based-UE-DifferentiationInfo-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct Subscription_Based_UE_DifferentiationInfo : asn::sequence<7, 0, true, 7>
+{
+ static constexpr const char* name() {return "Subscription-Based-UE-DifferentiationInfo";}
+ using parent_t = asn::sequence<7, 0, true, 7>;
+ struct periodicCommunicationIndicator_t : asn::enumerated<2, 0, true>
+ {
+ static constexpr const char* name() {return "periodicCommunicationIndicator_t";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ periodically
+ ,ondemand
+ } index_t;
+
+ };
+
+ periodicCommunicationIndicator_t& set_periodicCommunicationIndicator() { periodicCommunicationIndicator.setpresent(true); return periodicCommunicationIndicator;}
+ periodicCommunicationIndicator_t const* get_periodicCommunicationIndicator() const {return periodicCommunicationIndicator.is_valid() ? &periodicCommunicationIndicator : nullptr;}
+ struct periodicTime_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<true,asn::span<1, 3600>>;
+ static constexpr const char* name() {return "periodicTime_t";}
+ using parent_t = asn::integer<>;
+ static constexpr bool optional = true;
+
+ };
+
+ periodicTime_t& set_periodicTime() { periodicTime.setpresent(true); return periodicTime;}
+ periodicTime_t const* get_periodicTime() const {return periodicTime.is_valid() ? &periodicTime : nullptr;}
+ struct scheduledCommunicationTime_t : ScheduledCommunicationTime
+ {
+ static constexpr const char* name() {return "scheduledCommunicationTime_t";}
+ using parent_t = ScheduledCommunicationTime;
+ static constexpr bool optional = true;
+
+ };
+ scheduledCommunicationTime_t& set_scheduledCommunicationTime() { scheduledCommunicationTime.setpresent(true); return scheduledCommunicationTime;}
+ scheduledCommunicationTime_t const* get_scheduledCommunicationTime() const {return scheduledCommunicationTime.is_valid() ? &scheduledCommunicationTime : nullptr;}
+ struct stationaryIndication_t : asn::enumerated<2, 0, true>
+ {
+ static constexpr const char* name() {return "stationaryIndication_t";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ stationary
+ ,mobile
+ } index_t;
+
+ };
+
+ stationaryIndication_t& set_stationaryIndication() { stationaryIndication.setpresent(true); return stationaryIndication;}
+ stationaryIndication_t const* get_stationaryIndication() const {return stationaryIndication.is_valid() ? &stationaryIndication : nullptr;}
+ struct trafficProfile_t : asn::enumerated<3, 0, true>
+ {
+ static constexpr const char* name() {return "trafficProfile_t";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ single_packet
+ ,dual_packets
+ ,multiple_packets
+ } index_t;
+
+ };
+
+ trafficProfile_t& set_trafficProfile() { trafficProfile.setpresent(true); return trafficProfile;}
+ trafficProfile_t const* get_trafficProfile() const {return trafficProfile.is_valid() ? &trafficProfile : nullptr;}
+ struct batteryIndication_t : asn::enumerated<3, 0, true>
+ {
+ static constexpr const char* name() {return "batteryIndication_t";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ static constexpr bool optional = true;
+ typedef enum {
+ battery_powered
+ ,battery_powered_not_rechargeable_or_replaceable
+ ,not_battery_powered
+ } index_t;
+
+ };
+
+ batteryIndication_t& set_batteryIndication() { batteryIndication.setpresent(true); return batteryIndication;}
+ batteryIndication_t const* get_batteryIndication() const {return batteryIndication.is_valid() ? &batteryIndication : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(periodicCommunicationIndicator);
+ v(periodicTime);
+ v(scheduledCommunicationTime);
+ v(stationaryIndication);
+ v(trafficProfile);
+ v(batteryIndication);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(periodicCommunicationIndicator);
+ v(periodicTime);
+ v(scheduledCommunicationTime);
+ v(stationaryIndication);
+ v(trafficProfile);
+ v(batteryIndication);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ periodicCommunicationIndicator.clear();
+ periodicTime.clear();
+ scheduledCommunicationTime.clear();
+ stationaryIndication.clear();
+ trafficProfile.clear();
+ batteryIndication.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ periodicCommunicationIndicator_t periodicCommunicationIndicator;
+ periodicTime_t periodicTime;
+ scheduledCommunicationTime_t scheduledCommunicationTime;
+ stationaryIndication_t stationaryIndication;
+ trafficProfile_t trafficProfile;
+ batteryIndication_t batteryIndication;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TargetCellInUTRAN ::= OCTET STRING -- This IE is to be encoded according to the UTRAN Cell ID in the Last Visited UTRAN Cell Information IE in TS 25.413 [24]
+*/
+
+struct TargetCellInUTRAN : asn::ostring<>
+{
+ static constexpr const char* name() {return "TargetCellInUTRAN";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+TargeteNBtoSource-eNBTransparentContainer ::= OCTET STRING
+*/
+
+struct TargeteNBtoSource_eNBTransparentContainer : asn::ostring<>
+{
+ static constexpr const char* name() {return "TargeteNBtoSource-eNBTransparentContainer";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+TimeToWait ::= ENUMERATED {
+ v1s,
+ v2s,
+ v5s,
+ v10s,
+ v20s,
+ v60s,
+ ...
+}
+*/
+
+struct TimeToWait : asn::enumerated<6, 0, true>
+{
+ static constexpr const char* name() {return "TimeToWait";}
+ using parent_t = asn::enumerated<6, 0, true>;
+ typedef enum {
+ v1s
+ ,v2s
+ ,v5s
+ ,v10s
+ ,v20s
+ ,v60s
+ } index_t;
+
+};
+
+/*
+TraceDepth ::= ENUMERATED {
+ minimum,
+ medium,
+ maximum,
+ minimumWithoutVendorSpecificExtension,
+ mediumWithoutVendorSpecificExtension,
+ maximumWithoutVendorSpecificExtension,
+ ...
+}
+*/
+
+struct TraceDepth : asn::enumerated<6, 0, true>
+{
+ static constexpr const char* name() {return "TraceDepth";}
+ using parent_t = asn::enumerated<6, 0, true>;
+ typedef enum {
+ minimum
+ ,medium
+ ,maximum
+ ,minimumWithoutVendorSpecificExtension
+ ,mediumWithoutVendorSpecificExtension
+ ,maximumWithoutVendorSpecificExtension
+ } index_t;
+
+};
+
+/*
+TraceCollectionEntityIPAddress ::= BIT STRING (SIZE(1..160, ...))
+*/
+
+struct TraceCollectionEntityIPAddress : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 160>>;
+ static constexpr const char* name() {return "TraceCollectionEntityIPAddress";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+UEAppLayerMeasConfig-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ {ID id-serviceType CRITICALITY ignore EXTENSION ServiceType PRESENCE optional},
+ ...
+}
+*/
+
+struct UEAppLayerMeasConfig_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_serviceType() { set(id_serviceType); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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_serviceType)) { 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_serviceType);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_serviceType() { set(ignore); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ ServiceType& select_id_serviceType() { return set<ServiceType>(1); }
+ ServiceType const* get_id_serviceType() const { return get<ServiceType>(1); }
+ bool is_unknown() const { return type == 2; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<ServiceType>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<ServiceType>(1);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_serviceType()); 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<ServiceType>()); 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(ServiceType)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 2; }
+ void clear() {type = 0;}
+ void select_id_serviceType() { set(optional); type=1;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+UEAppLayerMeasConfig ::= SEQUENCE {
+ containerForAppLayerMeasConfig OCTET STRING (SIZE(1..1000)),
+ areaScopeOfQMC AreaScopeOfQMC,
+ iE-Extensions ProtocolExtensionContainer { {UEAppLayerMeasConfig-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UEAppLayerMeasConfig : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "UEAppLayerMeasConfig";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct containerForAppLayerMeasConfig_t : asn::ostring<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<1, 1000>>;
+ static constexpr const char* name() {return "containerForAppLayerMeasConfig_t";}
+ using parent_t = asn::ostring<>;
+
+ };
+
+ containerForAppLayerMeasConfig_t& ref_containerForAppLayerMeasConfig() {return containerForAppLayerMeasConfig;}
+ containerForAppLayerMeasConfig_t const& ref_containerForAppLayerMeasConfig() const {return containerForAppLayerMeasConfig;}
+ struct areaScopeOfQMC_t : AreaScopeOfQMC
+ {
+ static constexpr const char* name() {return "areaScopeOfQMC_t";}
+ using parent_t = AreaScopeOfQMC;
+
+ };
+ areaScopeOfQMC_t& ref_areaScopeOfQMC() {return areaScopeOfQMC;}
+ areaScopeOfQMC_t const& ref_areaScopeOfQMC() const {return areaScopeOfQMC;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(containerForAppLayerMeasConfig);
+ v(areaScopeOfQMC);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(containerForAppLayerMeasConfig);
+ v(areaScopeOfQMC);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ containerForAppLayerMeasConfig.clear();
+ areaScopeOfQMC.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ containerForAppLayerMeasConfig_t containerForAppLayerMeasConfig;
+ areaScopeOfQMC_t areaScopeOfQMC;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+TraceActivation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-MDTConfiguration CRITICALITY ignore EXTENSION MDT-Configuration PRESENCE optional}|
+ { ID id-UEAppLayerMeasConfig CRITICALITY ignore EXTENSION UEAppLayerMeasConfig PRESENCE optional},
+ ...
+}
+*/
+
+struct TraceActivation_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_MDTConfiguration() { set(id_MDTConfiguration); type=1;}
+ void select_id_UEAppLayerMeasConfig() { set(id_UEAppLayerMeasConfig); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_MDTConfiguration)) { type = 1; return true; }
+ else if(equal(id_UEAppLayerMeasConfig)) { 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_MDTConfiguration);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_UEAppLayerMeasConfig);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_MDTConfiguration() { set(ignore); type=1;}
+ void select_id_UEAppLayerMeasConfig() { set(ignore); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { 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(ignore);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ MDT_Configuration& select_id_MDTConfiguration() { return set<MDT_Configuration>(1); }
+ MDT_Configuration const* get_id_MDTConfiguration() const { return get<MDT_Configuration>(1); }
+ UEAppLayerMeasConfig& select_id_UEAppLayerMeasConfig() { return set<UEAppLayerMeasConfig>(2); }
+ UEAppLayerMeasConfig const* get_id_UEAppLayerMeasConfig() const { return get<UEAppLayerMeasConfig>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<MDT_Configuration>(); break;
+ case 2: var.destroy<UEAppLayerMeasConfig>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<MDT_Configuration>(1);
+ v.template operator()<UEAppLayerMeasConfig>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_MDTConfiguration()); return true;
+ case 2: v(select_id_UEAppLayerMeasConfig()); 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<MDT_Configuration>()); return true;
+ case 2: v(var.as<UEAppLayerMeasConfig>()); 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(MDT_Configuration)];
+ char dummy2[sizeof(UEAppLayerMeasConfig)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_MDTConfiguration() { set(optional); type=1;}
+ void select_id_UEAppLayerMeasConfig() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+TraceActivation ::= SEQUENCE {
+ eUTRANTraceID EUTRANTraceID,
+ interfacesToTrace InterfacesToTrace,
+traceDepth TraceDepth,
+traceCollectionEntityIPAddress TraceCollectionEntityIPAddress,
+ iE-Extensions ProtocolExtensionContainer { {TraceActivation-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TraceActivation : asn::sequence<5, 0, true, 1>
+{
+ static constexpr const char* name() {return "TraceActivation";}
+ using parent_t = asn::sequence<5, 0, true, 1>;
+ struct eUTRANTraceID_t : EUTRANTraceID
+ {
+ static constexpr const char* name() {return "eUTRANTraceID_t";}
+ using parent_t = EUTRANTraceID;
+
+ };
+ eUTRANTraceID_t& ref_eUTRANTraceID() {return eUTRANTraceID;}
+ eUTRANTraceID_t const& ref_eUTRANTraceID() const {return eUTRANTraceID;}
+ struct interfacesToTrace_t : InterfacesToTrace
+ {
+ static constexpr const char* name() {return "interfacesToTrace_t";}
+ using parent_t = InterfacesToTrace;
+
+ };
+ interfacesToTrace_t& ref_interfacesToTrace() {return interfacesToTrace;}
+ interfacesToTrace_t const& ref_interfacesToTrace() const {return interfacesToTrace;}
+ struct traceDepth_t : TraceDepth
+ {
+ static constexpr const char* name() {return "traceDepth_t";}
+ using parent_t = TraceDepth;
+
+ };
+ traceDepth_t& ref_traceDepth() {return traceDepth;}
+ traceDepth_t const& ref_traceDepth() const {return traceDepth;}
+ struct traceCollectionEntityIPAddress_t : TraceCollectionEntityIPAddress
+ {
+ static constexpr const char* name() {return "traceCollectionEntityIPAddress_t";}
+ using parent_t = TraceCollectionEntityIPAddress;
+
+ };
+ traceCollectionEntityIPAddress_t& ref_traceCollectionEntityIPAddress() {return traceCollectionEntityIPAddress;}
+ traceCollectionEntityIPAddress_t const& ref_traceCollectionEntityIPAddress() const {return traceCollectionEntityIPAddress;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<TraceActivation_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<TraceActivation_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(eUTRANTraceID);
+ v(interfacesToTrace);
+ v(traceDepth);
+ v(traceCollectionEntityIPAddress);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(eUTRANTraceID);
+ v(interfacesToTrace);
+ v(traceDepth);
+ v(traceCollectionEntityIPAddress);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ eUTRANTraceID.clear();
+ interfacesToTrace.clear();
+ traceDepth.clear();
+ traceCollectionEntityIPAddress.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ eUTRANTraceID_t eUTRANTraceID;
+ interfacesToTrace_t interfacesToTrace;
+ traceDepth_t traceDepth;
+ traceCollectionEntityIPAddress_t traceCollectionEntityIPAddress;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+Tunnel-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct Tunnel_Information_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+TunnelInformation ::= SEQUENCE {
+ transportLayerAddress TransportLayerAddress,
+ uDP-Port-Number Port-Number OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {Tunnel-Information-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct TunnelInformation : asn::sequence<3, 0, true, 2>
+{
+ static constexpr const char* name() {return "TunnelInformation";}
+ using parent_t = asn::sequence<3, 0, true, 2>;
+ struct transportLayerAddress_t : TransportLayerAddress
+ {
+ static constexpr const char* name() {return "transportLayerAddress_t";}
+ using parent_t = TransportLayerAddress;
+
+ };
+ transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
+ transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
+ struct uDP_Port_Number_t : Port_Number
+ {
+ static constexpr const char* name() {return "uDP_Port_Number_t";}
+ using parent_t = Port_Number;
+ static constexpr bool optional = true;
+
+ };
+ uDP_Port_Number_t& set_uDP_Port_Number() { uDP_Port_Number.setpresent(true); return uDP_Port_Number;}
+ uDP_Port_Number_t const* get_uDP_Port_Number() const {return uDP_Port_Number.is_valid() ? &uDP_Port_Number : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<Tunnel_Information_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<Tunnel_Information_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(transportLayerAddress);
+ v(uDP_Port_Number);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(transportLayerAddress);
+ v(uDP_Port_Number);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ transportLayerAddress.clear();
+ uDP_Port_Number.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ transportLayerAddress_t transportLayerAddress;
+ uDP_Port_Number_t uDP_Port_Number;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UE-ContextKeptIndicator ::= ENUMERATED {
+ true,
+ ...
+}
+*/
+
+struct UE_ContextKeptIndicator : asn::enumerated<1, 0, true>
+{
+ static constexpr const char* name() {return "UE-ContextKeptIndicator";}
+ using parent_t = asn::enumerated<1, 0, true>;
+ typedef enum {
+ True
+ } index_t;
+
+};
+
+/*
+UE-HistoryInformation ::= SEQUENCE (SIZE(1..maxnoofCells)) OF LastVisitedCell-Item
+*/
+
+struct UE_HistoryInformation_elm : LastVisitedCell_Item
+{
+ static constexpr const char* name() {return "UE_HistoryInformation_elm";}
+ using parent_t = LastVisitedCell_Item;
+
+};
+struct UE_HistoryInformation : asn::sequenceof<UE_HistoryInformation_elm>
+{
+ static constexpr const char* name() {return "UE-HistoryInformation";}
+ using parent_t = asn::sequenceof<UE_HistoryInformation_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxnoofCells >>;
+
+};
+/*
+UE-HistoryInformationFromTheUE ::= OCTET STRING
+*/
+
+struct UE_HistoryInformationFromTheUE : asn::ostring<>
+{
+ static constexpr const char* name() {return "UE-HistoryInformationFromTheUE";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-RLF-Report-Container::= OCTET STRING
+*/
+
+struct UE_RLF_Report_Container : asn::ostring<>
+{
+ static constexpr const char* name() {return "UE-RLF-Report-Container";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-RLF-Report-Container-for-extended-bands ::= OCTET STRING
+*/
+
+struct UE_RLF_Report_Container_for_extended_bands : asn::ostring<>
+{
+ static constexpr const char* name() {return "UE-RLF-Report-Container-for-extended-bands";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+UE-S1AP-ID ::= INTEGER (0.. 4294967295)
+*/
+
+struct UE_S1AP_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
+ static constexpr const char* name() {return "UE-S1AP-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UE-X2AP-ID ::= INTEGER (0..4095)
+*/
+
+struct UE_X2AP_ID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "UE-X2AP-ID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UE-X2AP-ID-Extension ::= INTEGER (0..4095, ...)
+*/
+
+struct UE_X2AP_ID_Extension : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "UE-X2AP-ID-Extension";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+UEAggregate-MaximumBitrate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ { ID id-extended-uEaggregateMaximumBitRateDownlink CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
+ { ID id-extended-uEaggregateMaximumBitRateUplink CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional},
+ ...
+}
+*/
+
+struct UEAggregate_MaximumBitrate_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(id_extended_uEaggregateMaximumBitRateDownlink); type=1;}
+ void select_id_extended_uEaggregateMaximumBitRateUplink() { set(id_extended_uEaggregateMaximumBitRateUplink); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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_extended_uEaggregateMaximumBitRateDownlink)) { type = 1; return true; }
+ else if(equal(id_extended_uEaggregateMaximumBitRateUplink)) { 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_extended_uEaggregateMaximumBitRateDownlink);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateUplink);} 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(ignore); type=1;}
+ void select_id_extended_uEaggregateMaximumBitRateUplink() { set(ignore); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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 if(equal(ignore)) { 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(ignore);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateDownlink() { return set<ExtendedBitRate>(1); }
+ ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateDownlink() const { return get<ExtendedBitRate>(1); }
+ ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateUplink() { return set<ExtendedBitRate>(2); }
+ ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateUplink() const { return get<ExtendedBitRate>(2); }
+ bool is_unknown() const { return type == 3; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<ExtendedBitRate>(); break;
+ case 2: var.destroy<ExtendedBitRate>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<ExtendedBitRate>(1);
+ v.template operator()<ExtendedBitRate>(2);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_extended_uEaggregateMaximumBitRateDownlink()); return true;
+ case 2: v(select_id_extended_uEaggregateMaximumBitRateUplink()); 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<ExtendedBitRate>()); return true;
+ case 2: v(var.as<ExtendedBitRate>()); 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(ExtendedBitRate)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 3; }
+ void clear() {type = 0;}
+ void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(optional); type=1;}
+ void select_id_extended_uEaggregateMaximumBitRateUplink() { set(optional); type=2;}
+ X2AP_PROTOCOL_EXTENSION::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};
+
+ };
+
+};
+/*
+UEAggregateMaximumBitRate ::= SEQUENCE {
+ uEaggregateMaximumBitRateDownlink BitRate,
+ uEaggregateMaximumBitRateUplink BitRate,
+ iE-Extensions ProtocolExtensionContainer { {UEAggregate-MaximumBitrate-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UEAggregateMaximumBitRate : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "UEAggregateMaximumBitRate";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct uEaggregateMaximumBitRateDownlink_t : BitRate
+ {
+ static constexpr const char* name() {return "uEaggregateMaximumBitRateDownlink_t";}
+ using parent_t = BitRate;
+
+ };
+ uEaggregateMaximumBitRateDownlink_t& ref_uEaggregateMaximumBitRateDownlink() {return uEaggregateMaximumBitRateDownlink;}
+ uEaggregateMaximumBitRateDownlink_t const& ref_uEaggregateMaximumBitRateDownlink() const {return uEaggregateMaximumBitRateDownlink;}
+ struct uEaggregateMaximumBitRateUplink_t : BitRate
+ {
+ static constexpr const char* name() {return "uEaggregateMaximumBitRateUplink_t";}
+ using parent_t = BitRate;
+
+ };
+ uEaggregateMaximumBitRateUplink_t& ref_uEaggregateMaximumBitRateUplink() {return uEaggregateMaximumBitRateUplink;}
+ uEaggregateMaximumBitRateUplink_t const& ref_uEaggregateMaximumBitRateUplink() const {return uEaggregateMaximumBitRateUplink;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uEaggregateMaximumBitRateDownlink);
+ v(uEaggregateMaximumBitRateUplink);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uEaggregateMaximumBitRateDownlink);
+ v(uEaggregateMaximumBitRateUplink);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uEaggregateMaximumBitRateDownlink.clear();
+ uEaggregateMaximumBitRateUplink.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uEaggregateMaximumBitRateDownlink_t uEaggregateMaximumBitRateDownlink;
+ uEaggregateMaximumBitRateUplink_t uEaggregateMaximumBitRateUplink;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UENRMeasurement-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UENRMeasurement_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UENRMeasurement ::= SEQUENCE {
+ uENRMeasurements RRCContainer,
+ iE-Extensions ProtocolExtensionContainer { {UENRMeasurement-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UENRMeasurement : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "UENRMeasurement";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct uENRMeasurements_t : RRCContainer
+ {
+ static constexpr const char* name() {return "uENRMeasurements_t";}
+ using parent_t = RRCContainer;
+
+ };
+ uENRMeasurements_t& ref_uENRMeasurements() {return uENRMeasurements;}
+ uENRMeasurements_t const& ref_uENRMeasurements() const {return uENRMeasurements;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UENRMeasurement_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UENRMeasurement_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uENRMeasurements);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uENRMeasurements);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uENRMeasurements.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uENRMeasurements_t uENRMeasurements;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UESecurityCapabilities_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UESecurityCapabilities ::= SEQUENCE {
+ encryptionAlgorithms EncryptionAlgorithms,
+ integrityProtectionAlgorithms IntegrityProtectionAlgorithms,
+ iE-Extensions ProtocolExtensionContainer { {UESecurityCapabilities-ExtIEs} } OPTIONAL,
+...
+}
+*/
+
+struct UESecurityCapabilities : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "UESecurityCapabilities";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct encryptionAlgorithms_t : EncryptionAlgorithms
+ {
+ static constexpr const char* name() {return "encryptionAlgorithms_t";}
+ using parent_t = EncryptionAlgorithms;
+
+ };
+ encryptionAlgorithms_t& ref_encryptionAlgorithms() {return encryptionAlgorithms;}
+ encryptionAlgorithms_t const& ref_encryptionAlgorithms() const {return encryptionAlgorithms;}
+ struct integrityProtectionAlgorithms_t : IntegrityProtectionAlgorithms
+ {
+ static constexpr const char* name() {return "integrityProtectionAlgorithms_t";}
+ using parent_t = IntegrityProtectionAlgorithms;
+
+ };
+ integrityProtectionAlgorithms_t& ref_integrityProtectionAlgorithms() {return integrityProtectionAlgorithms;}
+ integrityProtectionAlgorithms_t const& ref_integrityProtectionAlgorithms() const {return integrityProtectionAlgorithms;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(encryptionAlgorithms);
+ v(integrityProtectionAlgorithms);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(encryptionAlgorithms);
+ v(integrityProtectionAlgorithms);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ encryptionAlgorithms.clear();
+ integrityProtectionAlgorithms.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ encryptionAlgorithms_t encryptionAlgorithms;
+ integrityProtectionAlgorithms_t integrityProtectionAlgorithms;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UESidelinkAggregateMaximumBitRate ::= SEQUENCE {
+ uESidelinkAggregateMaximumBitRate BitRate,
+ iE-Extensions ProtocolExtensionContainer { {UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UESidelinkAggregateMaximumBitRate : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "UESidelinkAggregateMaximumBitRate";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct uESidelinkAggregateMaximumBitRate_t : BitRate
+ {
+ static constexpr const char* name() {return "uESidelinkAggregateMaximumBitRate_t";}
+ using parent_t = BitRate;
+
+ };
+ uESidelinkAggregateMaximumBitRate_t& ref_uESidelinkAggregateMaximumBitRate() {return uESidelinkAggregateMaximumBitRate;}
+ uESidelinkAggregateMaximumBitRate_t const& ref_uESidelinkAggregateMaximumBitRate() const {return uESidelinkAggregateMaximumBitRate;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uESidelinkAggregateMaximumBitRate);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uESidelinkAggregateMaximumBitRate);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uESidelinkAggregateMaximumBitRate.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uESidelinkAggregateMaximumBitRate_t uESidelinkAggregateMaximumBitRate;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UEsToBeResetList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UEsToBeResetList_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UEsToBeResetList-Item::= SEQUENCE {
+ meNB-ID UE-X2AP-ID,
+ meNB-ID-ext UE-X2AP-ID-Extension OPTIONAL,
+ sgNB-ID SgNB-UE-X2AP-ID OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {UEsToBeResetList-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UEsToBeResetList_Item : asn::sequence<4, 0, true, 3>
+{
+ static constexpr const char* name() {return "UEsToBeResetList-Item";}
+ using parent_t = asn::sequence<4, 0, true, 3>;
+ struct meNB_ID_t : UE_X2AP_ID
+ {
+ static constexpr const char* name() {return "meNB_ID_t";}
+ using parent_t = UE_X2AP_ID;
+
+ };
+ meNB_ID_t& ref_meNB_ID() {return meNB_ID;}
+ meNB_ID_t const& ref_meNB_ID() const {return meNB_ID;}
+ struct meNB_ID_ext_t : UE_X2AP_ID_Extension
+ {
+ static constexpr const char* name() {return "meNB_ID_ext_t";}
+ using parent_t = UE_X2AP_ID_Extension;
+ static constexpr bool optional = true;
+
+ };
+ meNB_ID_ext_t& set_meNB_ID_ext() { meNB_ID_ext.setpresent(true); return meNB_ID_ext;}
+ meNB_ID_ext_t const* get_meNB_ID_ext() const {return meNB_ID_ext.is_valid() ? &meNB_ID_ext : nullptr;}
+ struct sgNB_ID_t : SgNB_UE_X2AP_ID
+ {
+ static constexpr const char* name() {return "sgNB_ID_t";}
+ using parent_t = SgNB_UE_X2AP_ID;
+ static constexpr bool optional = true;
+
+ };
+ sgNB_ID_t& set_sgNB_ID() { sgNB_ID.setpresent(true); return sgNB_ID;}
+ sgNB_ID_t const* get_sgNB_ID() const {return sgNB_ID.is_valid() ? &sgNB_ID : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(meNB_ID);
+ v(meNB_ID_ext);
+ v(sgNB_ID);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(meNB_ID);
+ v(meNB_ID_ext);
+ v(sgNB_ID);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ meNB_ID.clear();
+ meNB_ID_ext.clear();
+ sgNB_ID.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ meNB_ID_t meNB_ID;
+ meNB_ID_ext_t meNB_ID_ext;
+ sgNB_ID_t sgNB_ID;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UEsToBeResetList ::= SEQUENCE (SIZE (1.. maxUEsinengNBDU)) OF UEsToBeResetList-Item
+*/
+
+struct UEsToBeResetList_elm : UEsToBeResetList_Item
+{
+ static constexpr const char* name() {return "UEsToBeResetList_elm";}
+ using parent_t = UEsToBeResetList_Item;
+
+};
+struct UEsToBeResetList : asn::sequenceof<UEsToBeResetList_elm>
+{
+ static constexpr const char* name() {return "UEsToBeResetList";}
+ using parent_t = asn::sequenceof<UEsToBeResetList_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxUEsinengNBDU >>;
+
+};
+/*
+UL-HighInterferenceIndication ::= BIT STRING (SIZE(1..110, ...))
+*/
+
+struct UL_HighInterferenceIndication : asn::bstring<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 110>>;
+ static constexpr const char* name() {return "UL-HighInterferenceIndication";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+UL-HighInterferenceIndicationInfo-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct UL_HighInterferenceIndicationInfo_Item_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+UL-HighInterferenceIndicationInfo-Item ::= SEQUENCE {
+ target-Cell-ID ECGI,
+ ul-interferenceindication UL-HighInterferenceIndication,
+ iE-Extensions ProtocolExtensionContainer { {UL-HighInterferenceIndicationInfo-Item-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct UL_HighInterferenceIndicationInfo_Item : asn::sequence<3, 0, true, 1>
+{
+ static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo-Item";}
+ using parent_t = asn::sequence<3, 0, true, 1>;
+ struct target_Cell_ID_t : ECGI
+ {
+ static constexpr const char* name() {return "target_Cell_ID_t";}
+ using parent_t = ECGI;
+
+ };
+ target_Cell_ID_t& ref_target_Cell_ID() {return target_Cell_ID;}
+ target_Cell_ID_t const& ref_target_Cell_ID() const {return target_Cell_ID;}
+ struct ul_interferenceindication_t : UL_HighInterferenceIndication
+ {
+ static constexpr const char* name() {return "ul_interferenceindication_t";}
+ using parent_t = UL_HighInterferenceIndication;
+
+ };
+ ul_interferenceindication_t& ref_ul_interferenceindication() {return ul_interferenceindication;}
+ ul_interferenceindication_t const& ref_ul_interferenceindication() const {return ul_interferenceindication;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(target_Cell_ID);
+ v(ul_interferenceindication);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(target_Cell_ID);
+ v(ul_interferenceindication);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ target_Cell_ID.clear();
+ ul_interferenceindication.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ target_Cell_ID_t target_Cell_ID;
+ ul_interferenceindication_t ul_interferenceindication;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+UL-HighInterferenceIndicationInfo ::= SEQUENCE (SIZE(1..maxCellineNB)) OF UL-HighInterferenceIndicationInfo-Item
+*/
+
+struct UL_HighInterferenceIndicationInfo_elm : UL_HighInterferenceIndicationInfo_Item
+{
+ static constexpr const char* name() {return "UL_HighInterferenceIndicationInfo_elm";}
+ using parent_t = UL_HighInterferenceIndicationInfo_Item;
+
+};
+struct UL_HighInterferenceIndicationInfo : asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>
+{
+ static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo";}
+ using parent_t = asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>;
+ using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
+
+};
+/*
+UL-UE-Configuration::= ENUMERATED { no-data, shared, only, ... }
+*/
+
+struct UL_UE_Configuration : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "UL-UE-Configuration";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ no_data
+ ,shared
+ ,only
+ } index_t;
+
+};
+
+/*
+ULConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct ULConfiguration_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+ULConfiguration::= SEQUENCE {
+ uL-PDCP UL-UE-Configuration,
+ iE-Extensions ProtocolExtensionContainer { {ULConfiguration-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct ULConfiguration : asn::sequence<2, 0, true, 1>
+{
+ static constexpr const char* name() {return "ULConfiguration";}
+ using parent_t = asn::sequence<2, 0, true, 1>;
+ struct uL_PDCP_t : UL_UE_Configuration
+ {
+ static constexpr const char* name() {return "uL_PDCP_t";}
+ using parent_t = UL_UE_Configuration;
+
+ };
+ uL_PDCP_t& ref_uL_PDCP() {return uL_PDCP;}
+ uL_PDCP_t const& ref_uL_PDCP() const {return uL_PDCP;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<ULConfiguration_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<ULConfiguration_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(uL_PDCP);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(uL_PDCP);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ uL_PDCP.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ uL_PDCP_t uL_PDCP;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+VehicleUE ::= ENUMERATED {
+ authorized,
+ not-authorized,
+ ...
+}
+*/
+
+struct VehicleUE : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "VehicleUE";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ authorized
+ ,not_authorized
+ } index_t;
+
+};
+
+/*
+V2XServicesAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
+ ...
+}
+*/
+
+struct V2XServicesAuthorized_ExtIEs
+{
+ struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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_EXTENSION::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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 Extension_t : asn::typefield<true>
+ {
+ ~Extension_t() {clear();}
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear()
+ {
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) return false;
+ return false;
+
+ }
+ private:
+ size_t type {0};
+
+ };
+ struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 1; }
+ void clear() {type = 0;}
+ X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ { type = 1; 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; 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};
+
+ };
+
+};
+/*
+V2XServicesAuthorized ::= SEQUENCE {
+ vehicleUE VehicleUE OPTIONAL,
+pedestrianUE PedestrianUE OPTIONAL,
+ iE-Extensions ProtocolExtensionContainer { {V2XServicesAuthorized-ExtIEs} } OPTIONAL,
+ ...
+}
+*/
+
+struct V2XServicesAuthorized : asn::sequence<3, 0, true, 3>
+{
+ static constexpr const char* name() {return "V2XServicesAuthorized";}
+ using parent_t = asn::sequence<3, 0, true, 3>;
+ struct vehicleUE_t : VehicleUE
+ {
+ static constexpr const char* name() {return "vehicleUE_t";}
+ using parent_t = VehicleUE;
+ static constexpr bool optional = true;
+
+ };
+ vehicleUE_t& set_vehicleUE() { vehicleUE.setpresent(true); return vehicleUE;}
+ vehicleUE_t const* get_vehicleUE() const {return vehicleUE.is_valid() ? &vehicleUE : nullptr;}
+ struct pedestrianUE_t : PedestrianUE
+ {
+ static constexpr const char* name() {return "pedestrianUE_t";}
+ using parent_t = PedestrianUE;
+ static constexpr bool optional = true;
+
+ };
+ pedestrianUE_t& set_pedestrianUE() { pedestrianUE.setpresent(true); return pedestrianUE;}
+ pedestrianUE_t const* get_pedestrianUE() const {return pedestrianUE.is_valid() ? &pedestrianUE : nullptr;}
+ struct iE_Extensions_t : ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>
+ {
+ static constexpr const char* name() {return "iE_Extensions_t";}
+ using parent_t = ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>;
+ static constexpr bool optional = true;
+
+ };
+ iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
+ iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
+ template<typename V> void decode(V& v)
+ {
+ v(vehicleUE);
+ v(pedestrianUE);
+ v(iE_Extensions);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(vehicleUE);
+ v(pedestrianUE);
+ v(iE_Extensions);
+
+ };
+ void clear()
+ {
+ vehicleUE.clear();
+ pedestrianUE.clear();
+ iE_Extensions.clear();
+
+ };
+ private:
+ vehicleUE_t vehicleUE;
+ pedestrianUE_t pedestrianUE;
+ iE_Extensions_t iE_Extensions;
+
+};
+/*
+WT-UE-XwAP-ID ::= OCTET STRING (SIZE (3))
+*/
+
+struct WT_UE_XwAP_ID : asn::ostring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<3>>;
+ static constexpr const char* name() {return "WT-UE-XwAP-ID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+WTID-Type1 ::= SEQUENCE {
+ pLMN-Identity PLMN-Identity,
+ shortWTID BIT STRING (SIZE(24)),
+ ...
+}
+*/
+
+struct WTID_Type1 : asn::sequence<2, 0, true, 0>
+{
+ static constexpr const char* name() {return "WTID-Type1";}
+ using parent_t = asn::sequence<2, 0, true, 0>;
+ struct pLMN_Identity_t : PLMN_Identity
+ {
+ static constexpr const char* name() {return "pLMN_Identity_t";}
+ using parent_t = PLMN_Identity;
+
+ };
+ pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
+ pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
+ struct shortWTID_t : asn::bstring<>
+ {
+ using constraint_t = asn::constraints<false,asn::one<24>>;
+ static constexpr const char* name() {return "shortWTID_t";}
+ using parent_t = asn::bstring<>;
+
+ };
+
+ shortWTID_t& ref_shortWTID() {return shortWTID;}
+ shortWTID_t const& ref_shortWTID() const {return shortWTID;}
+ template<typename V> void decode(V& v)
+ {
+ v(pLMN_Identity);
+ v(shortWTID);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(pLMN_Identity);
+ v(shortWTID);
+
+ };
+ void clear()
+ {
+ pLMN_Identity.clear();
+ shortWTID.clear();
+
+ };
+ private:
+ pLMN_Identity_t pLMN_Identity;
+ shortWTID_t shortWTID;
+
+};
+/*
+WTID-Long-Type2 ::= BIT STRING (SIZE(48))
+*/
+
+struct WTID_Long_Type2 : asn::bstring<>
+{
+ using constraint_t = asn::constraints<false,asn::one<48>>;
+ static constexpr const char* name() {return "WTID-Long-Type2";}
+ using parent_t = asn::bstring<>;
+
+};
+
+/*
+WTID ::= CHOICE {
+ wTID-Type1 WTID-Type1,
+ wTID-Type2 WTID-Long-Type2,
+ ...
+}
+*/
+
+struct WTID : asn::choice<2, 0, true>
+{
+ static constexpr const char* name() {return "WTID";}
+ using parent_t = asn::choice<2, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 3;}
+ void set_unknown() { set_index(3); }
+ ~WTID() {clear();}
+ struct wTID_Type1_t : WTID_Type1
+ {
+ static constexpr const char* name() {return "wTID_Type1_t";}
+ using parent_t = WTID_Type1;
+
+ };
+ struct wTID_Type2_t : WTID_Long_Type2
+ {
+ static constexpr const char* name() {return "wTID_Type2_t";}
+ using parent_t = WTID_Long_Type2;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<wTID_Type1_t>(); break;
+ case 2: var.destroy<wTID_Type2_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<wTID_Type1_t>());
+ case 2: set_index(2); return v(var.build<wTID_Type2_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<wTID_Type1_t>());
+ case 2: return v(var.as<wTID_Type2_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<wTID_Type1_t>(1);
+ v.template operator()<wTID_Type2_t>(2);
+
+ }
+ wTID_Type1_t& select_wTID_Type1() { if(get_index() != 1) { clear(); set_index(1); return var.build<wTID_Type1_t>();} return var.as<wTID_Type1_t>();}
+ wTID_Type1_t const* get_wTID_Type1() const { if(get_index() == 1) { return &var.as<wTID_Type1_t>();} return nullptr; }
+ wTID_Type2_t& select_wTID_Type2() { if(get_index() != 2) { clear(); set_index(2); return var.build<wTID_Type2_t>();} return var.as<wTID_Type2_t>();}
+ wTID_Type2_t const* get_wTID_Type2() const { if(get_index() == 2) { return &var.as<wTID_Type2_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(wTID_Type1_t)];
+ char dummy2[sizeof(wTID_Type2_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+X2BenefitValue ::= INTEGER (1..8, ...)
+*/
+
+struct X2BenefitValue : asn::integer<>
+{
+ using constraint_t = asn::constraints<true,asn::span<1, 8>>;
+ static constexpr const char* name() {return "X2BenefitValue";}
+ using parent_t = asn::integer<>;
+
+};
Code Review / sim / e2-interface.git / blobdiff