X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=sim%2Fe2-interface.git;a=blobdiff_plain;f=e2sim%2Fe2apv1sim%2Fsrc%2FASN1%2Fgenerated%2FE2AP-PDU-Descriptions.hpp;fp=e2sim%2Fe2apv1sim%2Fsrc%2FASN1%2Fgenerated%2FE2AP-PDU-Descriptions.hpp;h=f426b9715165db06225ce8d22d43ebf1e203de7e;hp=0000000000000000000000000000000000000000;hb=0eba05c4ff0c99974d3f3a63b65cbe2adb209e51;hpb=c380e183231711cf9f8bc72d0eb52e532dd07085

diff --git a/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Descriptions.hpp b/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Descriptions.hpp
new file mode 100644
index 0000000..f426b97
--- /dev/null
+++ b/e2sim/e2apv1sim/src/ASN1/generated/E2AP-PDU-Descriptions.hpp
@@ -0,0 +1,980 @@
+/*****************************************************************************
+# 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};
+};