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