--- /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-CommonDataTypes.hpp"
+#include "X2AP-PDU-Contents.hpp"
+#include "X2AP-Constants.hpp"
+#include "E2AP-PDU-Contents.hpp"
+#include "E2AP-Constants.hpp"
+
+/*
+E2AP-ELEMENTARY-PROCEDURE ::= CLASS {
+ &InitiatingMessage ,
+ &SuccessfulOutcome OPTIONAL,
+ &UnsuccessfulOutcome OPTIONAL,
+ &procedureCode ProcedureCode UNIQUE,
+ &criticality Criticality DEFAULT ignore
+}
+WITH SYNTAX {
+ INITIATING MESSAGE &InitiatingMessage
+ [SUCCESSFUL OUTCOME &SuccessfulOutcome]
+ [UNSUCCESSFUL OUTCOME &UnsuccessfulOutcome]
+ PROCEDURE CODE &procedureCode
+ [CRITICALITY &criticality]
+}
+*/
+
+struct E2AP_ELEMENTARY_PROCEDURE
+{
+ struct procedureCode_t : ProcedureCode
+ {
+ static constexpr const char* name() {return "procedureCode_t";}
+ using parent_t = ProcedureCode;
+
+ };
+ struct criticality_t : Criticality
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = Criticality;
+
+ };
+
+};
+/*
+E2AP-ELEMENTARY-PROCEDURES E2AP-ELEMENTARY-PROCEDURE ::= {
+ E2AP-ELEMENTARY-PROCEDURES-CLASS-1 |
+ E2AP-ELEMENTARY-PROCEDURES-CLASS-2,
+ ...
+}
+*/
+
+struct E2AP_ELEMENTARY_PROCEDURES
+{
+ struct InitiatingMessage_t : asn::typefield<true>
+ {
+ ~InitiatingMessage_t() {clear();}
+ size_t get_index() const {return type;}
+ RICsubscriptionRequest& select_id_ricSubscription() { return set<RICsubscriptionRequest>(1); }
+ RICsubscriptionRequest const* get_id_ricSubscription() const { return get<RICsubscriptionRequest>(1); }
+ RICsubscriptionDeleteRequest& select_id_ricSubscriptionDelete() { return set<RICsubscriptionDeleteRequest>(2); }
+ RICsubscriptionDeleteRequest const* get_id_ricSubscriptionDelete() const { return get<RICsubscriptionDeleteRequest>(2); }
+ RICserviceUpdate& select_id_ricServiceUpdate() { return set<RICserviceUpdate>(3); }
+ RICserviceUpdate const* get_id_ricServiceUpdate() const { return get<RICserviceUpdate>(3); }
+ RICcontrolRequest& select_id_ricControl() { return set<RICcontrolRequest>(4); }
+ RICcontrolRequest const* get_id_ricControl() const { return get<RICcontrolRequest>(4); }
+ X2SetupRequest& select_id_x2Setup() { return set<X2SetupRequest>(5); }
+ X2SetupRequest const* get_id_x2Setup() const { return get<X2SetupRequest>(5); }
+ ENDCX2SetupRequest& select_id_endcX2Setup() { return set<ENDCX2SetupRequest>(6); }
+ ENDCX2SetupRequest const* get_id_endcX2Setup() const { return get<ENDCX2SetupRequest>(6); }
+ ResourceStatusRequest& select_id_resourceStatusReportingInitiation() { return set<ResourceStatusRequest>(7); }
+ ResourceStatusRequest const* get_id_resourceStatusReportingInitiation() const { return get<ResourceStatusRequest>(7); }
+ ENBConfigurationUpdate& select_id_eNBConfigurationUpdate() { return set<ENBConfigurationUpdate>(8); }
+ ENBConfigurationUpdate const* get_id_eNBConfigurationUpdate() const { return get<ENBConfigurationUpdate>(8); }
+ ENDCConfigurationUpdate& select_id_endcConfigurationUpdate() { return set<ENDCConfigurationUpdate>(9); }
+ ENDCConfigurationUpdate const* get_id_endcConfigurationUpdate() const { return get<ENDCConfigurationUpdate>(9); }
+ ResetRequest& select_id_reset() { return set<ResetRequest>(10); }
+ ResetRequest const* get_id_reset() const { return get<ResetRequest>(10); }
+ RICindication& select_id_ricIndication() { return set<RICindication>(11); }
+ RICindication const* get_id_ricIndication() const { return get<RICindication>(11); }
+ RICserviceQuery& select_id_ricServiceQuery() { return set<RICserviceQuery>(12); }
+ RICserviceQuery const* get_id_ricServiceQuery() const { return get<RICserviceQuery>(12); }
+ LoadInformation& select_id_loadIndication() { return set<LoadInformation>(13); }
+ LoadInformation const* get_id_loadIndication() const { return get<LoadInformation>(13); }
+ GNBStatusIndication& select_id_gNBStatusIndication() { return set<GNBStatusIndication>(14); }
+ GNBStatusIndication const* get_id_gNBStatusIndication() const { return get<GNBStatusIndication>(14); }
+ ResourceStatusUpdate& select_id_resourceStatusReporting() { return set<ResourceStatusUpdate>(15); }
+ ResourceStatusUpdate const* get_id_resourceStatusReporting() const { return get<ResourceStatusUpdate>(15); }
+ ErrorIndication& select_id_errorIndication() { return set<ErrorIndication>(16); }
+ ErrorIndication const* get_id_errorIndication() const { return get<ErrorIndication>(16); }
+ bool is_unknown() const { return type == 17; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICsubscriptionRequest>(); break;
+ case 2: var.destroy<RICsubscriptionDeleteRequest>(); break;
+ case 3: var.destroy<RICserviceUpdate>(); break;
+ case 4: var.destroy<RICcontrolRequest>(); break;
+ case 5: var.destroy<X2SetupRequest>(); break;
+ case 6: var.destroy<ENDCX2SetupRequest>(); break;
+ case 7: var.destroy<ResourceStatusRequest>(); break;
+ case 8: var.destroy<ENBConfigurationUpdate>(); break;
+ case 9: var.destroy<ENDCConfigurationUpdate>(); break;
+ case 10: var.destroy<ResetRequest>(); break;
+ case 11: var.destroy<RICindication>(); break;
+ case 12: var.destroy<RICserviceQuery>(); break;
+ case 13: var.destroy<LoadInformation>(); break;
+ case 14: var.destroy<GNBStatusIndication>(); break;
+ case 15: var.destroy<ResourceStatusUpdate>(); break;
+ case 16: var.destroy<ErrorIndication>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICsubscriptionRequest>(1);
+ v.template operator()<RICsubscriptionDeleteRequest>(2);
+ v.template operator()<RICserviceUpdate>(3);
+ v.template operator()<RICcontrolRequest>(4);
+ v.template operator()<X2SetupRequest>(5);
+ v.template operator()<ENDCX2SetupRequest>(6);
+ v.template operator()<ResourceStatusRequest>(7);
+ v.template operator()<ENBConfigurationUpdate>(8);
+ v.template operator()<ENDCConfigurationUpdate>(9);
+ v.template operator()<ResetRequest>(10);
+ v.template operator()<RICindication>(11);
+ v.template operator()<RICserviceQuery>(12);
+ v.template operator()<LoadInformation>(13);
+ v.template operator()<GNBStatusIndication>(14);
+ v.template operator()<ResourceStatusUpdate>(15);
+ v.template operator()<ErrorIndication>(16);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_ricSubscription()); return true;
+ case 2: v(select_id_ricSubscriptionDelete()); return true;
+ case 3: v(select_id_ricServiceUpdate()); return true;
+ case 4: v(select_id_ricControl()); return true;
+ case 5: v(select_id_x2Setup()); return true;
+ case 6: v(select_id_endcX2Setup()); return true;
+ case 7: v(select_id_resourceStatusReportingInitiation()); return true;
+ case 8: v(select_id_eNBConfigurationUpdate()); return true;
+ case 9: v(select_id_endcConfigurationUpdate()); return true;
+ case 10: v(select_id_reset()); return true;
+ case 11: v(select_id_ricIndication()); return true;
+ case 12: v(select_id_ricServiceQuery()); return true;
+ case 13: v(select_id_loadIndication()); return true;
+ case 14: v(select_id_gNBStatusIndication()); return true;
+ case 15: v(select_id_resourceStatusReporting()); return true;
+ case 16: v(select_id_errorIndication()); return true;
+ case 17: if(type != 17) {clear(); asn::base::set();} type = 17; 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<RICsubscriptionRequest>()); return true;
+ case 2: v(var.as<RICsubscriptionDeleteRequest>()); return true;
+ case 3: v(var.as<RICserviceUpdate>()); return true;
+ case 4: v(var.as<RICcontrolRequest>()); return true;
+ case 5: v(var.as<X2SetupRequest>()); return true;
+ case 6: v(var.as<ENDCX2SetupRequest>()); return true;
+ case 7: v(var.as<ResourceStatusRequest>()); return true;
+ case 8: v(var.as<ENBConfigurationUpdate>()); return true;
+ case 9: v(var.as<ENDCConfigurationUpdate>()); return true;
+ case 10: v(var.as<ResetRequest>()); return true;
+ case 11: v(var.as<RICindication>()); return true;
+ case 12: v(var.as<RICserviceQuery>()); return true;
+ case 13: v(var.as<LoadInformation>()); return true;
+ case 14: v(var.as<GNBStatusIndication>()); return true;
+ case 15: v(var.as<ResourceStatusUpdate>()); return true;
+ case 16: v(var.as<ErrorIndication>()); 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(ENBConfigurationUpdate)];
+ char dummy2[sizeof(ENDCConfigurationUpdate)];
+ char dummy3[sizeof(ENDCX2SetupRequest)];
+ char dummy4[sizeof(ErrorIndication)];
+ char dummy5[sizeof(GNBStatusIndication)];
+ char dummy6[sizeof(LoadInformation)];
+ char dummy7[sizeof(RICcontrolRequest)];
+ char dummy8[sizeof(RICindication)];
+ char dummy9[sizeof(RICserviceQuery)];
+ char dummy10[sizeof(RICserviceUpdate)];
+ char dummy11[sizeof(RICsubscriptionDeleteRequest)];
+ char dummy12[sizeof(RICsubscriptionRequest)];
+ char dummy13[sizeof(ResetRequest)];
+ char dummy14[sizeof(ResourceStatusRequest)];
+ char dummy15[sizeof(ResourceStatusUpdate)];
+ char dummy16[sizeof(X2SetupRequest)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct SuccessfulOutcome_t : asn::typefield<true>
+ {
+ ~SuccessfulOutcome_t() {clear();}
+ size_t get_index() const {return type;}
+ RICsubscriptionResponse& select_id_ricSubscription() { return set<RICsubscriptionResponse>(1); }
+ RICsubscriptionResponse const* get_id_ricSubscription() const { return get<RICsubscriptionResponse>(1); }
+ RICsubscriptionDeleteResponse& select_id_ricSubscriptionDelete() { return set<RICsubscriptionDeleteResponse>(2); }
+ RICsubscriptionDeleteResponse const* get_id_ricSubscriptionDelete() const { return get<RICsubscriptionDeleteResponse>(2); }
+ RICserviceUpdateAcknowledge& select_id_ricServiceUpdate() { return set<RICserviceUpdateAcknowledge>(3); }
+ RICserviceUpdateAcknowledge const* get_id_ricServiceUpdate() const { return get<RICserviceUpdateAcknowledge>(3); }
+ RICcontrolAcknowledge& select_id_ricControl() { return set<RICcontrolAcknowledge>(4); }
+ RICcontrolAcknowledge const* get_id_ricControl() const { return get<RICcontrolAcknowledge>(4); }
+ X2SetupResponse& select_id_x2Setup() { return set<X2SetupResponse>(5); }
+ X2SetupResponse const* get_id_x2Setup() const { return get<X2SetupResponse>(5); }
+ ENDCX2SetupResponse& select_id_endcX2Setup() { return set<ENDCX2SetupResponse>(6); }
+ ENDCX2SetupResponse const* get_id_endcX2Setup() const { return get<ENDCX2SetupResponse>(6); }
+ ResourceStatusResponse& select_id_resourceStatusReportingInitiation() { return set<ResourceStatusResponse>(7); }
+ ResourceStatusResponse const* get_id_resourceStatusReportingInitiation() const { return get<ResourceStatusResponse>(7); }
+ ENBConfigurationUpdateAcknowledge& select_id_eNBConfigurationUpdate() { return set<ENBConfigurationUpdateAcknowledge>(8); }
+ ENBConfigurationUpdateAcknowledge const* get_id_eNBConfigurationUpdate() const { return get<ENBConfigurationUpdateAcknowledge>(8); }
+ ENDCConfigurationUpdateAcknowledge& select_id_endcConfigurationUpdate() { return set<ENDCConfigurationUpdateAcknowledge>(9); }
+ ENDCConfigurationUpdateAcknowledge const* get_id_endcConfigurationUpdate() const { return get<ENDCConfigurationUpdateAcknowledge>(9); }
+ ResetResponse& select_id_reset() { return set<ResetResponse>(10); }
+ ResetResponse const* get_id_reset() const { return get<ResetResponse>(10); }
+ bool is_unknown() const { return type == 17; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICsubscriptionResponse>(); break;
+ case 2: var.destroy<RICsubscriptionDeleteResponse>(); break;
+ case 3: var.destroy<RICserviceUpdateAcknowledge>(); break;
+ case 4: var.destroy<RICcontrolAcknowledge>(); break;
+ case 5: var.destroy<X2SetupResponse>(); break;
+ case 6: var.destroy<ENDCX2SetupResponse>(); break;
+ case 7: var.destroy<ResourceStatusResponse>(); break;
+ case 8: var.destroy<ENBConfigurationUpdateAcknowledge>(); break;
+ case 9: var.destroy<ENDCConfigurationUpdateAcknowledge>(); break;
+ case 10: var.destroy<ResetResponse>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICsubscriptionResponse>(1);
+ v.template operator()<RICsubscriptionDeleteResponse>(2);
+ v.template operator()<RICserviceUpdateAcknowledge>(3);
+ v.template operator()<RICcontrolAcknowledge>(4);
+ v.template operator()<X2SetupResponse>(5);
+ v.template operator()<ENDCX2SetupResponse>(6);
+ v.template operator()<ResourceStatusResponse>(7);
+ v.template operator()<ENBConfigurationUpdateAcknowledge>(8);
+ v.template operator()<ENDCConfigurationUpdateAcknowledge>(9);
+ v.template operator()<ResetResponse>(10);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_ricSubscription()); return true;
+ case 2: v(select_id_ricSubscriptionDelete()); return true;
+ case 3: v(select_id_ricServiceUpdate()); return true;
+ case 4: v(select_id_ricControl()); return true;
+ case 5: v(select_id_x2Setup()); return true;
+ case 6: v(select_id_endcX2Setup()); return true;
+ case 7: v(select_id_resourceStatusReportingInitiation()); return true;
+ case 8: v(select_id_eNBConfigurationUpdate()); return true;
+ case 9: v(select_id_endcConfigurationUpdate()); return true;
+ case 10: v(select_id_reset()); return true;
+ case 17: if(type != 17) {clear(); asn::base::set();} type = 17; 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<RICsubscriptionResponse>()); return true;
+ case 2: v(var.as<RICsubscriptionDeleteResponse>()); return true;
+ case 3: v(var.as<RICserviceUpdateAcknowledge>()); return true;
+ case 4: v(var.as<RICcontrolAcknowledge>()); return true;
+ case 5: v(var.as<X2SetupResponse>()); return true;
+ case 6: v(var.as<ENDCX2SetupResponse>()); return true;
+ case 7: v(var.as<ResourceStatusResponse>()); return true;
+ case 8: v(var.as<ENBConfigurationUpdateAcknowledge>()); return true;
+ case 9: v(var.as<ENDCConfigurationUpdateAcknowledge>()); return true;
+ case 10: v(var.as<ResetResponse>()); 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(ENBConfigurationUpdateAcknowledge)];
+ char dummy2[sizeof(ENDCConfigurationUpdateAcknowledge)];
+ char dummy3[sizeof(ENDCX2SetupResponse)];
+ char dummy4[sizeof(RICcontrolAcknowledge)];
+ char dummy5[sizeof(RICserviceUpdateAcknowledge)];
+ char dummy6[sizeof(RICsubscriptionDeleteResponse)];
+ char dummy7[sizeof(RICsubscriptionResponse)];
+ char dummy8[sizeof(ResetResponse)];
+ char dummy9[sizeof(ResourceStatusResponse)];
+ char dummy10[sizeof(X2SetupResponse)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct UnsuccessfulOutcome_t : asn::typefield<true>
+ {
+ ~UnsuccessfulOutcome_t() {clear();}
+ size_t get_index() const {return type;}
+ RICsubscriptionFailure& select_id_ricSubscription() { return set<RICsubscriptionFailure>(1); }
+ RICsubscriptionFailure const* get_id_ricSubscription() const { return get<RICsubscriptionFailure>(1); }
+ RICsubscriptionDeleteFailure& select_id_ricSubscriptionDelete() { return set<RICsubscriptionDeleteFailure>(2); }
+ RICsubscriptionDeleteFailure const* get_id_ricSubscriptionDelete() const { return get<RICsubscriptionDeleteFailure>(2); }
+ RICserviceUpdateFailure& select_id_ricServiceUpdate() { return set<RICserviceUpdateFailure>(3); }
+ RICserviceUpdateFailure const* get_id_ricServiceUpdate() const { return get<RICserviceUpdateFailure>(3); }
+ RICcontrolFailure& select_id_ricControl() { return set<RICcontrolFailure>(4); }
+ RICcontrolFailure const* get_id_ricControl() const { return get<RICcontrolFailure>(4); }
+ X2SetupFailure& select_id_x2Setup() { return set<X2SetupFailure>(5); }
+ X2SetupFailure const* get_id_x2Setup() const { return get<X2SetupFailure>(5); }
+ ENDCX2SetupFailure& select_id_endcX2Setup() { return set<ENDCX2SetupFailure>(6); }
+ ENDCX2SetupFailure const* get_id_endcX2Setup() const { return get<ENDCX2SetupFailure>(6); }
+ ResourceStatusFailure& select_id_resourceStatusReportingInitiation() { return set<ResourceStatusFailure>(7); }
+ ResourceStatusFailure const* get_id_resourceStatusReportingInitiation() const { return get<ResourceStatusFailure>(7); }
+ ENBConfigurationUpdateFailure& select_id_eNBConfigurationUpdate() { return set<ENBConfigurationUpdateFailure>(8); }
+ ENBConfigurationUpdateFailure const* get_id_eNBConfigurationUpdate() const { return get<ENBConfigurationUpdateFailure>(8); }
+ ENDCConfigurationUpdateFailure& select_id_endcConfigurationUpdate() { return set<ENDCConfigurationUpdateFailure>(9); }
+ ENDCConfigurationUpdateFailure const* get_id_endcConfigurationUpdate() const { return get<ENDCConfigurationUpdateFailure>(9); }
+ bool is_unknown() const { return type == 17; }
+ void clear()
+ {
+ switch(type)
+ {
+ case 1: var.destroy<RICsubscriptionFailure>(); break;
+ case 2: var.destroy<RICsubscriptionDeleteFailure>(); break;
+ case 3: var.destroy<RICserviceUpdateFailure>(); break;
+ case 4: var.destroy<RICcontrolFailure>(); break;
+ case 5: var.destroy<X2SetupFailure>(); break;
+ case 6: var.destroy<ENDCX2SetupFailure>(); break;
+ case 7: var.destroy<ResourceStatusFailure>(); break;
+ case 8: var.destroy<ENBConfigurationUpdateFailure>(); break;
+ case 9: var.destroy<ENDCConfigurationUpdateFailure>(); break;
+ }
+ type = 0; ref_nested().clear();
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<RICsubscriptionFailure>(1);
+ v.template operator()<RICsubscriptionDeleteFailure>(2);
+ v.template operator()<RICserviceUpdateFailure>(3);
+ v.template operator()<RICcontrolFailure>(4);
+ v.template operator()<X2SetupFailure>(5);
+ v.template operator()<ENDCX2SetupFailure>(6);
+ v.template operator()<ResourceStatusFailure>(7);
+ v.template operator()<ENBConfigurationUpdateFailure>(8);
+ v.template operator()<ENDCConfigurationUpdateFailure>(9);
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: v(select_id_ricSubscription()); return true;
+ case 2: v(select_id_ricSubscriptionDelete()); return true;
+ case 3: v(select_id_ricServiceUpdate()); return true;
+ case 4: v(select_id_ricControl()); return true;
+ case 5: v(select_id_x2Setup()); return true;
+ case 6: v(select_id_endcX2Setup()); return true;
+ case 7: v(select_id_resourceStatusReportingInitiation()); return true;
+ case 8: v(select_id_eNBConfigurationUpdate()); return true;
+ case 9: v(select_id_endcConfigurationUpdate()); return true;
+ case 17: if(type != 17) {clear(); asn::base::set();} type = 17; 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<RICsubscriptionFailure>()); return true;
+ case 2: v(var.as<RICsubscriptionDeleteFailure>()); return true;
+ case 3: v(var.as<RICserviceUpdateFailure>()); return true;
+ case 4: v(var.as<RICcontrolFailure>()); return true;
+ case 5: v(var.as<X2SetupFailure>()); return true;
+ case 6: v(var.as<ENDCX2SetupFailure>()); return true;
+ case 7: v(var.as<ResourceStatusFailure>()); return true;
+ case 8: v(var.as<ENBConfigurationUpdateFailure>()); return true;
+ case 9: v(var.as<ENDCConfigurationUpdateFailure>()); 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(ENBConfigurationUpdateFailure)];
+ char dummy2[sizeof(ENDCConfigurationUpdateFailure)];
+ char dummy3[sizeof(ENDCX2SetupFailure)];
+ char dummy4[sizeof(RICcontrolFailure)];
+ char dummy5[sizeof(RICserviceUpdateFailure)];
+ char dummy6[sizeof(RICsubscriptionDeleteFailure)];
+ char dummy7[sizeof(RICsubscriptionFailure)];
+ char dummy8[sizeof(ResourceStatusFailure)];
+ char dummy9[sizeof(X2SetupFailure)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ size_t type {0};
+
+ };
+ struct procedureCode_t : asn::fixedtypefield<E2AP_ELEMENTARY_PROCEDURE::procedureCode_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 17; }
+ void clear() {type = 0;}
+ void select_id_ricSubscription() { set(id_ricSubscription); type=1;}
+ void select_id_ricSubscriptionDelete() { set(id_ricSubscriptionDelete); type=2;}
+ void select_id_ricServiceUpdate() { set(id_ricServiceUpdate); type=3;}
+ void select_id_ricControl() { set(id_ricControl); type=4;}
+ void select_id_x2Setup() { set(id_x2Setup); type=5;}
+ void select_id_endcX2Setup() { set(id_endcX2Setup); type=6;}
+ void select_id_resourceStatusReportingInitiation() { set(id_resourceStatusReportingInitiation); type=7;}
+ void select_id_eNBConfigurationUpdate() { set(id_eNBConfigurationUpdate); type=8;}
+ void select_id_endcConfigurationUpdate() { set(id_endcConfigurationUpdate); type=9;}
+ void select_id_reset() { set(id_reset); type=10;}
+ void select_id_ricIndication() { set(id_ricIndication); type=11;}
+ void select_id_ricServiceQuery() { set(id_ricServiceQuery); type=12;}
+ void select_id_loadIndication() { set(id_loadIndication); type=13;}
+ void select_id_gNBStatusIndication() { set(id_gNBStatusIndication); type=14;}
+ void select_id_resourceStatusReporting() { set(id_resourceStatusReporting); type=15;}
+ void select_id_errorIndication() { set(id_errorIndication); type=16;}
+ E2AP_ELEMENTARY_PROCEDURE::procedureCode_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_ricSubscription)) { type = 1; return true; }
+ else if(equal(id_ricSubscriptionDelete)) { type = 2; return true; }
+ else if(equal(id_ricServiceUpdate)) { type = 3; return true; }
+ else if(equal(id_ricControl)) { type = 4; return true; }
+ else if(equal(id_x2Setup)) { type = 5; return true; }
+ else if(equal(id_endcX2Setup)) { type = 6; return true; }
+ else if(equal(id_resourceStatusReportingInitiation)) { type = 7; return true; }
+ else if(equal(id_eNBConfigurationUpdate)) { type = 8; return true; }
+ else if(equal(id_endcConfigurationUpdate)) { type = 9; return true; }
+ else if(equal(id_reset)) { type = 10; return true; }
+ else if(equal(id_ricIndication)) { type = 11; return true; }
+ else if(equal(id_ricServiceQuery)) { type = 12; return true; }
+ else if(equal(id_loadIndication)) { type = 13; return true; }
+ else if(equal(id_gNBStatusIndication)) { type = 14; return true; }
+ else if(equal(id_resourceStatusReporting)) { type = 15; return true; }
+ else if(equal(id_errorIndication)) { type = 16; return true; }
+ else { type = 17; return true;}
+ return false;
+
+ }
+ template<typename V> bool encode(V& 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_ricSubscription);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(id_ricSubscriptionDelete);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(id_ricServiceUpdate);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(id_ricControl);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(id_x2Setup);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(id_endcX2Setup);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(id_resourceStatusReportingInitiation);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(id_eNBConfigurationUpdate);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(id_endcConfigurationUpdate);} return false;
+ case 10: type = 10; if(v(ref_nested())) { return equal(id_reset);} return false;
+ case 11: type = 11; if(v(ref_nested())) { return equal(id_ricIndication);} return false;
+ case 12: type = 12; if(v(ref_nested())) { return equal(id_ricServiceQuery);} return false;
+ case 13: type = 13; if(v(ref_nested())) { return equal(id_loadIndication);} return false;
+ case 14: type = 14; if(v(ref_nested())) { return equal(id_gNBStatusIndication);} return false;
+ case 15: type = 15; if(v(ref_nested())) { return equal(id_resourceStatusReporting);} return false;
+ case 16: type = 16; if(v(ref_nested())) { return equal(id_errorIndication);} return false;
+ case 17: type = 17; return v(ref_nested());
+ ref_nested().clear();
+ }
+ return false;
+
+ }
+ template<typename 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<E2AP_ELEMENTARY_PROCEDURE::criticality_t, true>
+ {
+ size_t get_index() const {return type;}
+ bool is_unknown() const { return type == 17; }
+ void clear() {type = 0;}
+ void select_id_ricSubscription() { set(reject); type=1;}
+ void select_id_ricSubscriptionDelete() { set(reject); type=2;}
+ void select_id_ricServiceUpdate() { set(reject); type=3;}
+ void select_id_ricControl() { set(reject); type=4;}
+ void select_id_x2Setup() { set(reject); type=5;}
+ void select_id_endcX2Setup() { set(reject); type=6;}
+ void select_id_resourceStatusReportingInitiation() { set(reject); type=7;}
+ void select_id_eNBConfigurationUpdate() { set(reject); type=8;}
+ void select_id_endcConfigurationUpdate() { set(reject); type=9;}
+ void select_id_reset() { set(reject); type=10;}
+ void select_id_ricIndication() { set(ignore); type=11;}
+ void select_id_ricServiceQuery() { set(ignore); type=12;}
+ void select_id_loadIndication() { set(ignore); type=13;}
+ void select_id_gNBStatusIndication() { set(ignore); type=14;}
+ void select_id_resourceStatusReporting() { set(ignore); type=15;}
+ void select_id_errorIndication() { set(ignore); type=16;}
+ E2AP_ELEMENTARY_PROCEDURE::criticality_t const& ref_value() const {return ref_nested();}
+ template<typename V> bool decode(V& v)
+ {
+ clear();
+ if(!v(ref_nested())) return false;
+ if(equal(reject)) { type = 1; return true; }
+ else if(equal(reject)) { type = 2; return true; }
+ else if(equal(reject)) { type = 3; return true; }
+ else if(equal(reject)) { type = 4; return true; }
+ else if(equal(reject)) { type = 5; return true; }
+ else if(equal(reject)) { type = 6; return true; }
+ else if(equal(reject)) { type = 7; return true; }
+ else if(equal(reject)) { type = 8; return true; }
+ else if(equal(reject)) { type = 9; return true; }
+ else if(equal(reject)) { type = 10; return true; }
+ else if(equal(ignore)) { type = 11; return true; }
+ else if(equal(ignore)) { type = 12; return true; }
+ else if(equal(ignore)) { type = 13; return true; }
+ else if(equal(ignore)) { type = 14; return true; }
+ else if(equal(ignore)) { type = 15; return true; }
+ else if(equal(ignore)) { type = 16; return true; }
+ else { type = 17; return true;}
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ return v(ref_nested());
+
+ }
+ protected:
+ template<typename V> bool decode(size_t index, V& v)
+ {
+ clear();
+ switch(index)
+ {
+ case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
+ case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
+ case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
+ case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
+ case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
+ case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
+ case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
+ case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
+ case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
+ case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
+ case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 16: type = 16; if(v(ref_nested())) { return equal(ignore);} return false;
+ case 17: type = 17; return v(ref_nested());
+ ref_nested().clear();
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(size_t index, V& v) const
+ {
+ if(index != type) {return false;} return v(ref_nested());
+
+ }
+ private:
+ size_t type {0};
+
+ };
+
+};
+/*
+InitiatingMessage ::= SEQUENCE {
+ procedureCode E2AP-ELEMENTARY-PROCEDURE.&procedureCode({E2AP-ELEMENTARY-PROCEDURES}),
+ criticality E2AP-ELEMENTARY-PROCEDURE.&criticality({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode}),
+ value E2AP-ELEMENTARY-PROCEDURE.&InitiatingMessage({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode})
+}
+*/
+
+struct InitiatingMessage : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "InitiatingMessage";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct procedureCode_t : E2AP_ELEMENTARY_PROCEDURES::procedureCode_t
+ {
+ static constexpr const char* name() {return "procedureCode_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::procedureCode_t;
+ template<typename V> bool decode(V& v, InitiatingMessage const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, InitiatingMessage const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::encode(v);
+ };
+ };
+ procedureCode_t& ref_procedureCode() {return procedureCode;}
+ procedureCode_t const& ref_procedureCode() const {return procedureCode;}
+ struct criticality_t : E2AP_ELEMENTARY_PROCEDURES::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::criticality_t;
+ template<typename V> bool decode(V& v, InitiatingMessage const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, InitiatingMessage const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct value_t : E2AP_ELEMENTARY_PROCEDURES::InitiatingMessage_t
+ {
+ static constexpr const char* name() {return "value_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::InitiatingMessage_t;
+ template<typename V> bool decode(V& v, InitiatingMessage const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::InitiatingMessage_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, InitiatingMessage const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::InitiatingMessage_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ value_t& ref_value() {return value;}
+ value_t const& ref_value() const {return value;}
+ template<typename V> void decode(V& v)
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ void clear()
+ {
+ procedureCode.clear();
+ criticality.clear();
+ value.clear();
+
+ };
+ private:
+ procedureCode_t procedureCode;
+ criticality_t criticality;
+ value_t value;
+
+};
+/*
+SuccessfulOutcome ::= SEQUENCE {
+ procedureCode E2AP-ELEMENTARY-PROCEDURE.&procedureCode({E2AP-ELEMENTARY-PROCEDURES}),
+ criticality E2AP-ELEMENTARY-PROCEDURE.&criticality({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode}),
+ value E2AP-ELEMENTARY-PROCEDURE.&SuccessfulOutcome({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode})
+}
+*/
+
+struct SuccessfulOutcome : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "SuccessfulOutcome";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct procedureCode_t : E2AP_ELEMENTARY_PROCEDURES::procedureCode_t
+ {
+ static constexpr const char* name() {return "procedureCode_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::procedureCode_t;
+ template<typename V> bool decode(V& v, SuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, SuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::encode(v);
+ };
+ };
+ procedureCode_t& ref_procedureCode() {return procedureCode;}
+ procedureCode_t const& ref_procedureCode() const {return procedureCode;}
+ struct criticality_t : E2AP_ELEMENTARY_PROCEDURES::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::criticality_t;
+ template<typename V> bool decode(V& v, SuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, SuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct value_t : E2AP_ELEMENTARY_PROCEDURES::SuccessfulOutcome_t
+ {
+ static constexpr const char* name() {return "value_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::SuccessfulOutcome_t;
+ template<typename V> bool decode(V& v, SuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::SuccessfulOutcome_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, SuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::SuccessfulOutcome_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ value_t& ref_value() {return value;}
+ value_t const& ref_value() const {return value;}
+ template<typename V> void decode(V& v)
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ void clear()
+ {
+ procedureCode.clear();
+ criticality.clear();
+ value.clear();
+
+ };
+ private:
+ procedureCode_t procedureCode;
+ criticality_t criticality;
+ value_t value;
+
+};
+/*
+UnsuccessfulOutcome ::= SEQUENCE {
+ procedureCode E2AP-ELEMENTARY-PROCEDURE.&procedureCode({E2AP-ELEMENTARY-PROCEDURES}),
+ criticality E2AP-ELEMENTARY-PROCEDURE.&criticality({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode}),
+ value E2AP-ELEMENTARY-PROCEDURE.&UnsuccessfulOutcome({E2AP-ELEMENTARY-PROCEDURES}{@procedureCode})
+}
+*/
+
+struct UnsuccessfulOutcome : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "UnsuccessfulOutcome";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct procedureCode_t : E2AP_ELEMENTARY_PROCEDURES::procedureCode_t
+ {
+ static constexpr const char* name() {return "procedureCode_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::procedureCode_t;
+ template<typename V> bool decode(V& v, UnsuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, UnsuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::procedureCode_t::encode(v);
+ };
+ };
+ procedureCode_t& ref_procedureCode() {return procedureCode;}
+ procedureCode_t const& ref_procedureCode() const {return procedureCode;}
+ struct criticality_t : E2AP_ELEMENTARY_PROCEDURES::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::criticality_t;
+ template<typename V> bool decode(V& v, UnsuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, UnsuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::criticality_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct value_t : E2AP_ELEMENTARY_PROCEDURES::UnsuccessfulOutcome_t
+ {
+ static constexpr const char* name() {return "value_t";}
+ using parent_t = typename E2AP_ELEMENTARY_PROCEDURES::UnsuccessfulOutcome_t;
+ template<typename V> bool decode(V& v, UnsuccessfulOutcome const& c)
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::UnsuccessfulOutcome_t::decode(c.procedureCode.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, UnsuccessfulOutcome const& c) const
+ {
+ return E2AP_ELEMENTARY_PROCEDURES::UnsuccessfulOutcome_t::encode(c.procedureCode.get_index(), v);
+ };
+ };
+ value_t& ref_value() {return value;}
+ value_t const& ref_value() const {return value;}
+ template<typename V> void decode(V& v)
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(procedureCode);
+ v(criticality);
+ v(value);
+
+ };
+ void clear()
+ {
+ procedureCode.clear();
+ criticality.clear();
+ value.clear();
+
+ };
+ private:
+ procedureCode_t procedureCode;
+ criticality_t criticality;
+ value_t value;
+
+};
+/*
+E2AP-PDU ::= CHOICE {
+ initiatingMessage InitiatingMessage,
+ successfulOutcome SuccessfulOutcome,
+ unsuccessfulOutcome UnsuccessfulOutcome,
+ ...
+}
+*/
+
+struct E2AP_PDU : asn::choice<3, 0, true>
+{
+ static constexpr const char* name() {return "E2AP-PDU";}
+ 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); }
+ ~E2AP_PDU() {clear();}
+ struct initiatingMessage_t : InitiatingMessage
+ {
+ static constexpr const char* name() {return "initiatingMessage_t";}
+ using parent_t = InitiatingMessage;
+
+ };
+ struct successfulOutcome_t : SuccessfulOutcome
+ {
+ static constexpr const char* name() {return "successfulOutcome_t";}
+ using parent_t = SuccessfulOutcome;
+
+ };
+ struct unsuccessfulOutcome_t : UnsuccessfulOutcome
+ {
+ static constexpr const char* name() {return "unsuccessfulOutcome_t";}
+ using parent_t = UnsuccessfulOutcome;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<initiatingMessage_t>(); break;
+ case 2: var.destroy<successfulOutcome_t>(); break;
+ case 3: var.destroy<unsuccessfulOutcome_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<initiatingMessage_t>());
+ case 2: set_index(2); return v(var.build<successfulOutcome_t>());
+ case 3: set_index(3); return v(var.build<unsuccessfulOutcome_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<initiatingMessage_t>());
+ case 2: return v(var.as<successfulOutcome_t>());
+ case 3: return v(var.as<unsuccessfulOutcome_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<initiatingMessage_t>(1);
+ v.template operator()<successfulOutcome_t>(2);
+ v.template operator()<unsuccessfulOutcome_t>(3);
+
+ }
+ initiatingMessage_t& select_initiatingMessage() { if(get_index() != 1) { clear(); set_index(1); return var.build<initiatingMessage_t>();} return var.as<initiatingMessage_t>();}
+ initiatingMessage_t const* get_initiatingMessage() const { if(get_index() == 1) { return &var.as<initiatingMessage_t>();} return nullptr; }
+ successfulOutcome_t& select_successfulOutcome() { if(get_index() != 2) { clear(); set_index(2); return var.build<successfulOutcome_t>();} return var.as<successfulOutcome_t>();}
+ successfulOutcome_t const* get_successfulOutcome() const { if(get_index() == 2) { return &var.as<successfulOutcome_t>();} return nullptr; }
+ unsuccessfulOutcome_t& select_unsuccessfulOutcome() { if(get_index() != 3) { clear(); set_index(3); return var.build<unsuccessfulOutcome_t>();} return var.as<unsuccessfulOutcome_t>();}
+ unsuccessfulOutcome_t const* get_unsuccessfulOutcome() const { if(get_index() == 3) { return &var.as<unsuccessfulOutcome_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(initiatingMessage_t)];
+ char dummy2[sizeof(successfulOutcome_t)];
+ char dummy3[sizeof(unsuccessfulOutcome_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
Code Review / sim / e2-interface.git / blobdiff