--- /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-IEs.hpp"
+
+/*
+CauseRIC ::= ENUMERATED {
+ function-id-Invalid,
+ action-not-supported,
+ excessive-actions,
+ duplicate-action,
+ duplicate-event,
+ function-resource-limit,
+ request-id-unknown,
+ inconsistent-action-subsequent-action-sequence,
+ control-message-invalid,
+ call-process-id-invalid,
+ function-not-required,
+ excessive-functions,
+ ric-resource-limit,
+ ...
+}
+*/
+
+struct CauseRIC : asn::enumerated<13, 0, true>
+{
+ static constexpr const char* name() {return "CauseRIC";}
+ using parent_t = asn::enumerated<13, 0, true>;
+ typedef enum {
+ function_id_Invalid
+ ,action_not_supported
+ ,excessive_actions
+ ,duplicate_action
+ ,duplicate_event
+ ,function_resource_limit
+ ,request_id_unknown
+ ,inconsistent_action_subsequent_action_sequence
+ ,control_message_invalid
+ ,call_process_id_invalid
+ ,function_not_required
+ ,excessive_functions
+ ,ric_resource_limit
+ } index_t;
+
+};
+
+/*
+RANfunctionDefinition ::= OCTET STRING
+*/
+
+struct RANfunctionDefinition : asn::ostring<>
+{
+ static constexpr const char* name() {return "RANfunctionDefinition";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RANfunctionID ::= INTEGER (0..4095)
+*/
+
+struct RANfunctionID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
+ static constexpr const char* name() {return "RANfunctionID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+RICactionDefinition ::= OCTET STRING
+*/
+
+struct RICactionDefinition : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICactionDefinition";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICactionID ::= INTEGER (0..255)
+*/
+
+struct RICactionID : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 255>>;
+ static constexpr const char* name() {return "RICactionID";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+RICactionType ::= ENUMERATED{
+ report,
+ insert,
+ policy,
+ ...
+}
+*/
+
+struct RICactionType : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "RICactionType";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ report
+ ,insert
+ ,policy
+ } index_t;
+
+};
+
+/*
+RICcallProcessID ::= OCTET STRING
+*/
+
+struct RICcallProcessID : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICcallProcessID";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICcause ::= CHOICE {
+ radioNetwork CauseRadioNetwork,
+ transport CauseTransport,
+ protocol CauseProtocol,
+ misc CauseMisc,
+ ric CauseRIC,
+ ...
+}
+*/
+
+struct RICcause : asn::choice<5, 0, true>
+{
+ static constexpr const char* name() {return "RICcause";}
+ using parent_t = asn::choice<5, 0, true>;
+ index_type get_index() const {return index;}
+ bool is_unknown() const {return index == 6;}
+ void set_unknown() { set_index(6); }
+ ~RICcause() {clear();}
+ struct radioNetwork_t : CauseRadioNetwork
+ {
+ static constexpr const char* name() {return "radioNetwork_t";}
+ using parent_t = CauseRadioNetwork;
+
+ };
+ struct transport_t : CauseTransport
+ {
+ static constexpr const char* name() {return "transport_t";}
+ using parent_t = CauseTransport;
+
+ };
+ struct protocol_t : CauseProtocol
+ {
+ static constexpr const char* name() {return "protocol_t";}
+ using parent_t = CauseProtocol;
+
+ };
+ struct misc_t : CauseMisc
+ {
+ static constexpr const char* name() {return "misc_t";}
+ using parent_t = CauseMisc;
+
+ };
+ struct ric_t : CauseRIC
+ {
+ static constexpr const char* name() {return "ric_t";}
+ using parent_t = CauseRIC;
+
+ };
+ void clear()
+ {
+ switch(get_index())
+ {
+ case 1: var.destroy<radioNetwork_t>(); break;
+ case 2: var.destroy<transport_t>(); break;
+ case 3: var.destroy<protocol_t>(); break;
+ case 4: var.destroy<misc_t>(); break;
+ case 5: var.destroy<ric_t>(); break;
+ }
+ index = 0;
+ base::clear();
+ }
+ template<typename V> bool decode(size_t idx, V& v)
+ {
+ clear();
+ switch(idx)
+ {
+ case 1: set_index(1); return v(var.build<radioNetwork_t>());
+ case 2: set_index(2); return v(var.build<transport_t>());
+ case 3: set_index(3); return v(var.build<protocol_t>());
+ case 4: set_index(4); return v(var.build<misc_t>());
+ case 5: set_index(5); return v(var.build<ric_t>());
+ }
+ return false;
+
+ }
+ template<typename V> bool encode(V& v) const
+ {
+ switch(get_index())
+ {
+ case 1: return v(var.as<radioNetwork_t>());
+ case 2: return v(var.as<transport_t>());
+ case 3: return v(var.as<protocol_t>());
+ case 4: return v(var.as<misc_t>());
+ case 5: return v(var.as<ric_t>());
+ }
+ return false;
+ }
+ template<typename V> static inline void enumerate(V& v)
+ {
+ v.template operator()<radioNetwork_t>(1);
+ v.template operator()<transport_t>(2);
+ v.template operator()<protocol_t>(3);
+ v.template operator()<misc_t>(4);
+ v.template operator()<ric_t>(5);
+
+ }
+ radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
+ radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
+ transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
+ transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
+ protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
+ protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
+ misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
+ misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
+ ric_t& select_ric() { if(get_index() != 5) { clear(); set_index(5); return var.build<ric_t>();} return var.as<ric_t>();}
+ ric_t const* get_ric() const { if(get_index() == 5) { return &var.as<ric_t>();} return nullptr; }
+ private:
+ void set_index(index_type i) {index = i; base::set();}
+ union union_type
+ {
+ char dummy1[sizeof(radioNetwork_t)];
+ char dummy2[sizeof(transport_t)];
+ char dummy3[sizeof(protocol_t)];
+ char dummy4[sizeof(misc_t)];
+ char dummy5[sizeof(ric_t)];
+
+ };
+ asn::variant<sizeof(union_type)> var;
+ index_type index {0};
+};
+/*
+RICcontrolAckRequest ::= ENUMERATED{
+ noAck,
+ ack,
+ nAck,
+ ...
+}
+*/
+
+struct RICcontrolAckRequest : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "RICcontrolAckRequest";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ noAck
+ ,ack
+ ,nAck
+ } index_t;
+
+};
+
+/*
+RICcontrolHeader ::= OCTET STRING
+*/
+
+struct RICcontrolHeader : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICcontrolHeader";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICcontrolMessage ::= OCTET STRING
+*/
+
+struct RICcontrolMessage : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICcontrolMessage";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICcontrolStatus ::= ENUMERATED{
+ success,
+ rejected,
+ failed,
+ ...
+}
+*/
+
+struct RICcontrolStatus : asn::enumerated<3, 0, true>
+{
+ static constexpr const char* name() {return "RICcontrolStatus";}
+ using parent_t = asn::enumerated<3, 0, true>;
+ typedef enum {
+ success
+ ,rejected
+ ,failed
+ } index_t;
+
+};
+
+/*
+RICeventTriggerDefinition ::= OCTET STRING
+*/
+
+struct RICeventTriggerDefinition : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICeventTriggerDefinition";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICindicationHeader ::= OCTET STRING
+*/
+
+struct RICindicationHeader : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICindicationHeader";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICindicationMessage ::= OCTET STRING
+*/
+
+struct RICindicationMessage : asn::ostring<>
+{
+ static constexpr const char* name() {return "RICindicationMessage";}
+ using parent_t = asn::ostring<>;
+
+};
+
+/*
+RICindicationSN ::= INTEGER (0..65535)
+*/
+
+struct RICindicationSN : asn::integer<>
+{
+ using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
+ static constexpr const char* name() {return "RICindicationSN";}
+ using parent_t = asn::integer<>;
+
+};
+
+/*
+RICindicationType ::= ENUMERATED{
+ report,
+ insert,
+ ...
+}
+*/
+
+struct RICindicationType : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "RICindicationType";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ report
+ ,insert
+ } index_t;
+
+};
+
+/*
+RICrequestID ::= SEQUENCE {
+ ricRequestorID INTEGER (0..65535),
+ ricRequestSequenceNumber INTEGER (0..65535),
+ ...
+}
+*/
+
+struct RICrequestID : asn::sequence<2, 0, true, 0>
+{
+ static constexpr const char* name() {return "RICrequestID";}
+ using parent_t = asn::sequence<2, 0, true, 0>;
+ struct ricRequestorID_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
+ static constexpr const char* name() {return "ricRequestorID_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ ricRequestorID_t& ref_ricRequestorID() {return ricRequestorID;}
+ ricRequestorID_t const& ref_ricRequestorID() const {return ricRequestorID;}
+ struct ricRequestSequenceNumber_t : asn::integer<>
+ {
+ using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
+ static constexpr const char* name() {return "ricRequestSequenceNumber_t";}
+ using parent_t = asn::integer<>;
+
+ };
+
+ ricRequestSequenceNumber_t& ref_ricRequestSequenceNumber() {return ricRequestSequenceNumber;}
+ ricRequestSequenceNumber_t const& ref_ricRequestSequenceNumber() const {return ricRequestSequenceNumber;}
+ template<typename V> void decode(V& v)
+ {
+ v(ricRequestorID);
+ v(ricRequestSequenceNumber);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(ricRequestorID);
+ v(ricRequestSequenceNumber);
+
+ };
+ void clear()
+ {
+ ricRequestorID.clear();
+ ricRequestSequenceNumber.clear();
+
+ };
+ private:
+ ricRequestorID_t ricRequestorID;
+ ricRequestSequenceNumber_t ricRequestSequenceNumber;
+
+};
+/*
+RICsubsequentActionType ::= ENUMERATED{
+ continue,
+ wait,
+ ...
+}
+*/
+
+struct RICsubsequentActionType : asn::enumerated<2, 0, true>
+{
+ static constexpr const char* name() {return "RICsubsequentActionType";}
+ using parent_t = asn::enumerated<2, 0, true>;
+ typedef enum {
+ Continue
+ ,wait
+ } index_t;
+
+};
+
+/*
+RICtimeToWait ::= ENUMERATED{
+ zero,
+ w1ms,
+ w2ms,
+ w5ms,
+ w10ms,
+ w20ms,
+ w30ms,
+ w40ms,
+ w50ms,
+ w100ms,
+ w200ms,
+ w500ms,
+ w1s,
+ w2s,
+ w5s,
+ w10s,
+ w20s,
+ w60s,
+ ...
+}
+*/
+
+struct RICtimeToWait : asn::enumerated<18, 0, true>
+{
+ static constexpr const char* name() {return "RICtimeToWait";}
+ using parent_t = asn::enumerated<18, 0, true>;
+ typedef enum {
+ zero
+ ,w1ms
+ ,w2ms
+ ,w5ms
+ ,w10ms
+ ,w20ms
+ ,w30ms
+ ,w40ms
+ ,w50ms
+ ,w100ms
+ ,w200ms
+ ,w500ms
+ ,w1s
+ ,w2s
+ ,w5s
+ ,w10s
+ ,w20s
+ ,w60s
+ } index_t;
+
+};
+
+/*
+RICsubsequentAction ::=SEQUENCE{
+ ricSubsequentActionType RICsubsequentActionType,
+ ricTimeToWait RICtimeToWait,
+ ...
+}
+*/
+
+struct RICsubsequentAction : asn::sequence<2, 0, true, 0>
+{
+ static constexpr const char* name() {return "RICsubsequentAction";}
+ using parent_t = asn::sequence<2, 0, true, 0>;
+ struct ricSubsequentActionType_t : RICsubsequentActionType
+ {
+ static constexpr const char* name() {return "ricSubsequentActionType_t";}
+ using parent_t = RICsubsequentActionType;
+
+ };
+ ricSubsequentActionType_t& ref_ricSubsequentActionType() {return ricSubsequentActionType;}
+ ricSubsequentActionType_t const& ref_ricSubsequentActionType() const {return ricSubsequentActionType;}
+ struct ricTimeToWait_t : RICtimeToWait
+ {
+ static constexpr const char* name() {return "ricTimeToWait_t";}
+ using parent_t = RICtimeToWait;
+
+ };
+ ricTimeToWait_t& ref_ricTimeToWait() {return ricTimeToWait;}
+ ricTimeToWait_t const& ref_ricTimeToWait() const {return ricTimeToWait;}
+ template<typename V> void decode(V& v)
+ {
+ v(ricSubsequentActionType);
+ v(ricTimeToWait);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(ricSubsequentActionType);
+ v(ricTimeToWait);
+
+ };
+ void clear()
+ {
+ ricSubsequentActionType.clear();
+ ricTimeToWait.clear();
+
+ };
+ private:
+ ricSubsequentActionType_t ricSubsequentActionType;
+ ricTimeToWait_t ricTimeToWait;
+
+};
Code Review / sim / e2-interface.git / blobdiff