--- /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"
+
+/*
+X2AP-PRIVATE-IES ::= CLASS {
+ &id PrivateIE-ID,
+ &criticality Criticality,
+ &Value,
+ &presence Presence
+}
+WITH SYNTAX {
+ ID &id
+ CRITICALITY &criticality
+ TYPE &Value
+ PRESENCE &presence
+}
+*/
+
+struct X2AP_PRIVATE_IES
+{
+ struct id_t : PrivateIE_ID
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = PrivateIE_ID;
+
+ };
+ struct criticality_t : Criticality
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = Criticality;
+
+ };
+ struct presence_t : Presence
+ {
+ static constexpr const char* name() {return "presence_t";}
+ using parent_t = Presence;
+
+ };
+
+};
+/*
+PrivateIE-Field {X2AP-PRIVATE-IES : IEsSetParam} ::= SEQUENCE {
+ id X2AP-PRIVATE-IES.&id ({IEsSetParam}),
+ criticality X2AP-PRIVATE-IES.&criticality ({IEsSetParam}{@id}),
+ value X2AP-PRIVATE-IES.&Value ({IEsSetParam}{@id})
+}
+*/
+
+template<typename IEsSetParam>
+struct PrivateIE_Field : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "PrivateIE-Field";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct id_t : IEsSetParam::id_t
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = typename IEsSetParam::id_t;
+ template<typename V> bool decode(V& v, PrivateIE_Field const& c)
+ {
+ return IEsSetParam::id_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, PrivateIE_Field const& c) const
+ {
+ return IEsSetParam::id_t::encode(v);
+ };
+ };
+ id_t& ref_id() {return id;}
+ id_t const& ref_id() const {return id;}
+ struct criticality_t : IEsSetParam::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename IEsSetParam::criticality_t;
+ template<typename V> bool decode(V& v, PrivateIE_Field const& c)
+ {
+ return IEsSetParam::criticality_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, PrivateIE_Field const& c) const
+ {
+ return IEsSetParam::criticality_t::encode(c.id.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct value_t : IEsSetParam::Value_t
+ {
+ static constexpr const char* name() {return "value_t";}
+ using parent_t = typename IEsSetParam::Value_t;
+ template<typename V> bool decode(V& v, PrivateIE_Field const& c)
+ {
+ return IEsSetParam::Value_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, PrivateIE_Field const& c) const
+ {
+ return IEsSetParam::Value_t::encode(c.id.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(id);
+ v(criticality);
+ v(value);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(id);
+ v(criticality);
+ v(value);
+
+ };
+ void clear()
+ {
+ id.clear();
+ criticality.clear();
+ value.clear();
+
+ };
+ private:
+ id_t id;
+ criticality_t criticality;
+ value_t value;
+
+};
+/*
+PrivateIE-Container {X2AP-PRIVATE-IES : IEsSetParam} ::=
+ SEQUENCE (SIZE (1..maxPrivateIEs)) OF
+ PrivateIE-Field {{IEsSetParam}}
+*/
+
+template<typename IEsSetParam>
+struct PrivateIE_Container_elm : PrivateIE_Field<IEsSetParam>
+{
+ static constexpr const char* name() {return "PrivateIE_Container_elm";}
+ using parent_t = PrivateIE_Field<IEsSetParam>;
+
+};
+template<typename IEsSetParam>
+struct PrivateIE_Container : asn::sequenceof<PrivateIE_Container_elm <IEsSetParam> >
+{
+ static constexpr const char* name() {return "PrivateIE-Container";}
+ using parent_t = asn::sequenceof<PrivateIE_Container_elm <IEsSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span<1, maxPrivateIEs >>;
+
+};
+/*
+X2AP-PROTOCOL-EXTENSION ::= CLASS {
+ &id ProtocolIE-ID UNIQUE,
+ &criticality Criticality,
+ &Extension,
+ &presence Presence
+}
+WITH SYNTAX {
+ ID &id
+ CRITICALITY &criticality
+ EXTENSION &Extension
+ PRESENCE &presence
+}
+*/
+
+struct X2AP_PROTOCOL_EXTENSION
+{
+ struct id_t : ProtocolIE_ID
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = ProtocolIE_ID;
+
+ };
+ struct criticality_t : Criticality
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = Criticality;
+
+ };
+ struct presence_t : Presence
+ {
+ static constexpr const char* name() {return "presence_t";}
+ using parent_t = Presence;
+
+ };
+
+};
+/*
+ProtocolExtensionField {X2AP-PROTOCOL-EXTENSION : ExtensionSetParam} ::= SEQUENCE {
+ id X2AP-PROTOCOL-EXTENSION.&id ({ExtensionSetParam}),
+ criticality X2AP-PROTOCOL-EXTENSION.&criticality ({ExtensionSetParam}{@id}),
+ extensionValue X2AP-PROTOCOL-EXTENSION.&Extension ({ExtensionSetParam}{@id})
+}
+*/
+
+template<typename ExtensionSetParam>
+struct ProtocolExtensionField : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "ProtocolExtensionField";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct id_t : ExtensionSetParam::id_t
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = typename ExtensionSetParam::id_t;
+ template<typename V> bool decode(V& v, ProtocolExtensionField const& c)
+ {
+ return ExtensionSetParam::id_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, ProtocolExtensionField const& c) const
+ {
+ return ExtensionSetParam::id_t::encode(v);
+ };
+ };
+ id_t& ref_id() {return id;}
+ id_t const& ref_id() const {return id;}
+ struct criticality_t : ExtensionSetParam::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename ExtensionSetParam::criticality_t;
+ template<typename V> bool decode(V& v, ProtocolExtensionField const& c)
+ {
+ return ExtensionSetParam::criticality_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolExtensionField const& c) const
+ {
+ return ExtensionSetParam::criticality_t::encode(c.id.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct extensionValue_t : ExtensionSetParam::Extension_t
+ {
+ static constexpr const char* name() {return "extensionValue_t";}
+ using parent_t = typename ExtensionSetParam::Extension_t;
+ template<typename V> bool decode(V& v, ProtocolExtensionField const& c)
+ {
+ return ExtensionSetParam::Extension_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolExtensionField const& c) const
+ {
+ return ExtensionSetParam::Extension_t::encode(c.id.get_index(), v);
+ };
+ };
+ extensionValue_t& ref_extensionValue() {return extensionValue;}
+ extensionValue_t const& ref_extensionValue() const {return extensionValue;}
+ template<typename V> void decode(V& v)
+ {
+ v(id);
+ v(criticality);
+ v(extensionValue);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(id);
+ v(criticality);
+ v(extensionValue);
+
+ };
+ void clear()
+ {
+ id.clear();
+ criticality.clear();
+ extensionValue.clear();
+
+ };
+ private:
+ id_t id;
+ criticality_t criticality;
+ extensionValue_t extensionValue;
+
+};
+/*
+ProtocolExtensionContainer {X2AP-PROTOCOL-EXTENSION : ExtensionSetParam} ::=
+ SEQUENCE (SIZE (1..maxProtocolExtensions)) OF
+ ProtocolExtensionField {{ExtensionSetParam}}
+*/
+
+template<typename ExtensionSetParam>
+struct ProtocolExtensionContainer_elm : ProtocolExtensionField<ExtensionSetParam>
+{
+ static constexpr const char* name() {return "ProtocolExtensionContainer_elm";}
+ using parent_t = ProtocolExtensionField<ExtensionSetParam>;
+
+};
+template<typename ExtensionSetParam>
+struct ProtocolExtensionContainer : asn::sequenceof<ProtocolExtensionContainer_elm <ExtensionSetParam> >
+{
+ static constexpr const char* name() {return "ProtocolExtensionContainer";}
+ using parent_t = asn::sequenceof<ProtocolExtensionContainer_elm <ExtensionSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span<1, maxProtocolExtensions >>;
+
+};
+/*
+X2AP-PROTOCOL-IES ::= CLASS {
+ &id ProtocolIE-ID UNIQUE,
+ &criticality Criticality,
+ &Value,
+ &presence Presence
+}
+WITH SYNTAX {
+ ID &id
+ CRITICALITY &criticality
+ TYPE &Value
+ PRESENCE &presence
+}
+*/
+
+struct X2AP_PROTOCOL_IES
+{
+ struct id_t : ProtocolIE_ID
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = ProtocolIE_ID;
+
+ };
+ struct criticality_t : Criticality
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = Criticality;
+
+ };
+ struct presence_t : Presence
+ {
+ static constexpr const char* name() {return "presence_t";}
+ using parent_t = Presence;
+
+ };
+
+};
+/*
+ProtocolIE-Field {X2AP-PROTOCOL-IES : IEsSetParam} ::= SEQUENCE {
+ id X2AP-PROTOCOL-IES.&id ({IEsSetParam}),
+ criticality X2AP-PROTOCOL-IES.&criticality ({IEsSetParam}{@id}),
+ value X2AP-PROTOCOL-IES.&Value ({IEsSetParam}{@id})
+}
+*/
+
+template<typename IEsSetParam>
+struct ProtocolIE_Field : asn::sequence<3, 0, false, 0>
+{
+ static constexpr const char* name() {return "ProtocolIE-Field";}
+ using parent_t = asn::sequence<3, 0, false, 0>;
+ struct id_t : IEsSetParam::id_t
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = typename IEsSetParam::id_t;
+ template<typename V> bool decode(V& v, ProtocolIE_Field const& c)
+ {
+ return IEsSetParam::id_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_Field const& c) const
+ {
+ return IEsSetParam::id_t::encode(v);
+ };
+ };
+ id_t& ref_id() {return id;}
+ id_t const& ref_id() const {return id;}
+ struct criticality_t : IEsSetParam::criticality_t
+ {
+ static constexpr const char* name() {return "criticality_t";}
+ using parent_t = typename IEsSetParam::criticality_t;
+ template<typename V> bool decode(V& v, ProtocolIE_Field const& c)
+ {
+ return IEsSetParam::criticality_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_Field const& c) const
+ {
+ return IEsSetParam::criticality_t::encode(c.id.get_index(), v);
+ };
+ };
+ criticality_t& ref_criticality() {return criticality;}
+ criticality_t const& ref_criticality() const {return criticality;}
+ struct value_t : IEsSetParam::Value_t
+ {
+ static constexpr const char* name() {return "value_t";}
+ using parent_t = typename IEsSetParam::Value_t;
+ template<typename V> bool decode(V& v, ProtocolIE_Field const& c)
+ {
+ return IEsSetParam::Value_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_Field const& c) const
+ {
+ return IEsSetParam::Value_t::encode(c.id.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(id);
+ v(criticality);
+ v(value);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(id);
+ v(criticality);
+ v(value);
+
+ };
+ void clear()
+ {
+ id.clear();
+ criticality.clear();
+ value.clear();
+
+ };
+ private:
+ id_t id;
+ criticality_t criticality;
+ value_t value;
+
+};
+/*
+ProtocolIE-Container {X2AP-PROTOCOL-IES : IEsSetParam} ::=
+ SEQUENCE (SIZE (0..maxProtocolIEs)) OF
+ ProtocolIE-Field {{IEsSetParam}}
+*/
+
+template<typename IEsSetParam>
+struct ProtocolIE_Container_elm : ProtocolIE_Field<IEsSetParam>
+{
+ static constexpr const char* name() {return "ProtocolIE_Container_elm";}
+ using parent_t = ProtocolIE_Field<IEsSetParam>;
+
+};
+template<typename IEsSetParam>
+struct ProtocolIE_Container : asn::sequenceof<ProtocolIE_Container_elm <IEsSetParam> >
+{
+ static constexpr const char* name() {return "ProtocolIE-Container";}
+ using parent_t = asn::sequenceof<ProtocolIE_Container_elm <IEsSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span<0, maxProtocolIEs >>;
+
+};
+/*
+ProtocolIE-ContainerList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES : IEsSetParam} ::=
+ SEQUENCE (SIZE (lowerBound..upperBound)) OF
+ ProtocolIE-Container {{IEsSetParam}}
+*/
+
+template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
+struct ProtocolIE_ContainerList_elm : ProtocolIE_Container<IEsSetParam>
+{
+ static constexpr const char* name() {return "ProtocolIE_ContainerList_elm";}
+ using parent_t = ProtocolIE_Container<IEsSetParam>;
+
+};
+template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
+struct ProtocolIE_ContainerList : asn::sequenceof<ProtocolIE_ContainerList_elm <lowerBound, upperBound, IEsSetParam> >
+{
+ static constexpr const char* name() {return "ProtocolIE-ContainerList";}
+ using parent_t = asn::sequenceof<ProtocolIE_ContainerList_elm <lowerBound, upperBound, IEsSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span< lowerBound , upperBound >>;
+
+};
+/*
+X2AP-PROTOCOL-IES-PAIR ::= CLASS {
+ &id ProtocolIE-ID UNIQUE,
+ &firstCriticality Criticality,
+ &FirstValue,
+ &secondCriticality Criticality,
+ &SecondValue,
+ &presence Presence
+}
+WITH SYNTAX {
+ ID &id
+ FIRST CRITICALITY &firstCriticality
+ FIRST TYPE &FirstValue
+ SECOND CRITICALITY &secondCriticality
+ SECOND TYPE &SecondValue
+ PRESENCE &presence
+}
+*/
+
+struct X2AP_PROTOCOL_IES_PAIR
+{
+ struct id_t : ProtocolIE_ID
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = ProtocolIE_ID;
+
+ };
+ struct firstCriticality_t : Criticality
+ {
+ static constexpr const char* name() {return "firstCriticality_t";}
+ using parent_t = Criticality;
+
+ };
+ struct secondCriticality_t : Criticality
+ {
+ static constexpr const char* name() {return "secondCriticality_t";}
+ using parent_t = Criticality;
+
+ };
+ struct presence_t : Presence
+ {
+ static constexpr const char* name() {return "presence_t";}
+ using parent_t = Presence;
+
+ };
+
+};
+/*
+ProtocolIE-FieldPair {X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::= SEQUENCE {
+ id X2AP-PROTOCOL-IES-PAIR.&id ({IEsSetParam}),
+ firstCriticality X2AP-PROTOCOL-IES-PAIR.&firstCriticality ({IEsSetParam}{@id}),
+ firstValue X2AP-PROTOCOL-IES-PAIR.&FirstValue ({IEsSetParam}{@id}),
+ secondCriticality X2AP-PROTOCOL-IES-PAIR.&secondCriticality ({IEsSetParam}{@id}),
+ secondValue X2AP-PROTOCOL-IES-PAIR.&SecondValue ({IEsSetParam}{@id})
+}
+*/
+
+template<typename IEsSetParam>
+struct ProtocolIE_FieldPair : asn::sequence<5, 0, false, 0>
+{
+ static constexpr const char* name() {return "ProtocolIE-FieldPair";}
+ using parent_t = asn::sequence<5, 0, false, 0>;
+ struct id_t : IEsSetParam::id_t
+ {
+ static constexpr const char* name() {return "id_t";}
+ using parent_t = typename IEsSetParam::id_t;
+ template<typename V> bool decode(V& v, ProtocolIE_FieldPair const& c)
+ {
+ return IEsSetParam::id_t::decode(v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_FieldPair const& c) const
+ {
+ return IEsSetParam::id_t::encode(v);
+ };
+ };
+ id_t& ref_id() {return id;}
+ id_t const& ref_id() const {return id;}
+ struct firstCriticality_t : IEsSetParam::firstCriticality_t
+ {
+ static constexpr const char* name() {return "firstCriticality_t";}
+ using parent_t = typename IEsSetParam::firstCriticality_t;
+ template<typename V> bool decode(V& v, ProtocolIE_FieldPair const& c)
+ {
+ return IEsSetParam::firstCriticality_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_FieldPair const& c) const
+ {
+ return IEsSetParam::firstCriticality_t::encode(c.id.get_index(), v);
+ };
+ };
+ firstCriticality_t& ref_firstCriticality() {return firstCriticality;}
+ firstCriticality_t const& ref_firstCriticality() const {return firstCriticality;}
+ struct firstValue_t : IEsSetParam::FirstValue_t
+ {
+ static constexpr const char* name() {return "firstValue_t";}
+ using parent_t = typename IEsSetParam::FirstValue_t;
+ template<typename V> bool decode(V& v, ProtocolIE_FieldPair const& c)
+ {
+ return IEsSetParam::FirstValue_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_FieldPair const& c) const
+ {
+ return IEsSetParam::FirstValue_t::encode(c.id.get_index(), v);
+ };
+ };
+ firstValue_t& ref_firstValue() {return firstValue;}
+ firstValue_t const& ref_firstValue() const {return firstValue;}
+ struct secondCriticality_t : IEsSetParam::secondCriticality_t
+ {
+ static constexpr const char* name() {return "secondCriticality_t";}
+ using parent_t = typename IEsSetParam::secondCriticality_t;
+ template<typename V> bool decode(V& v, ProtocolIE_FieldPair const& c)
+ {
+ return IEsSetParam::secondCriticality_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_FieldPair const& c) const
+ {
+ return IEsSetParam::secondCriticality_t::encode(c.id.get_index(), v);
+ };
+ };
+ secondCriticality_t& ref_secondCriticality() {return secondCriticality;}
+ secondCriticality_t const& ref_secondCriticality() const {return secondCriticality;}
+ struct secondValue_t : IEsSetParam::SecondValue_t
+ {
+ static constexpr const char* name() {return "secondValue_t";}
+ using parent_t = typename IEsSetParam::SecondValue_t;
+ template<typename V> bool decode(V& v, ProtocolIE_FieldPair const& c)
+ {
+ return IEsSetParam::SecondValue_t::decode(c.id.get_index(), v);
+ };
+ template<typename V> bool encode(V& v, ProtocolIE_FieldPair const& c) const
+ {
+ return IEsSetParam::SecondValue_t::encode(c.id.get_index(), v);
+ };
+ };
+ secondValue_t& ref_secondValue() {return secondValue;}
+ secondValue_t const& ref_secondValue() const {return secondValue;}
+ template<typename V> void decode(V& v)
+ {
+ v(id);
+ v(firstCriticality);
+ v(firstValue);
+ v(secondCriticality);
+ v(secondValue);
+
+ };
+ template<typename V> void encode(V& v) const
+ {
+ v(id);
+ v(firstCriticality);
+ v(firstValue);
+ v(secondCriticality);
+ v(secondValue);
+
+ };
+ void clear()
+ {
+ id.clear();
+ firstCriticality.clear();
+ firstValue.clear();
+ secondCriticality.clear();
+ secondValue.clear();
+
+ };
+ private:
+ id_t id;
+ firstCriticality_t firstCriticality;
+ firstValue_t firstValue;
+ secondCriticality_t secondCriticality;
+ secondValue_t secondValue;
+
+};
+/*
+ProtocolIE-ContainerPair {X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::=
+ SEQUENCE (SIZE (0..maxProtocolIEs)) OF
+ ProtocolIE-FieldPair {{IEsSetParam}}
+*/
+
+template<typename IEsSetParam>
+struct ProtocolIE_ContainerPair_elm : ProtocolIE_FieldPair<IEsSetParam>
+{
+ static constexpr const char* name() {return "ProtocolIE_ContainerPair_elm";}
+ using parent_t = ProtocolIE_FieldPair<IEsSetParam>;
+
+};
+template<typename IEsSetParam>
+struct ProtocolIE_ContainerPair : asn::sequenceof<ProtocolIE_ContainerPair_elm <IEsSetParam> >
+{
+ static constexpr const char* name() {return "ProtocolIE-ContainerPair";}
+ using parent_t = asn::sequenceof<ProtocolIE_ContainerPair_elm <IEsSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span<0, maxProtocolIEs >>;
+
+};
+/*
+ProtocolIE-ContainerPairList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::=
+ SEQUENCE (SIZE (lowerBound..upperBound)) OF
+ ProtocolIE-ContainerPair {{IEsSetParam}}
+*/
+
+template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
+struct ProtocolIE_ContainerPairList_elm : ProtocolIE_ContainerPair<IEsSetParam>
+{
+ static constexpr const char* name() {return "ProtocolIE_ContainerPairList_elm";}
+ using parent_t = ProtocolIE_ContainerPair<IEsSetParam>;
+
+};
+template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
+struct ProtocolIE_ContainerPairList : asn::sequenceof<ProtocolIE_ContainerPairList_elm <lowerBound, upperBound, IEsSetParam> >
+{
+ static constexpr const char* name() {return "ProtocolIE-ContainerPairList";}
+ using parent_t = asn::sequenceof<ProtocolIE_ContainerPairList_elm <lowerBound, upperBound, IEsSetParam> >;
+ using constraint_t = asn::constraints<false,asn::span< lowerBound , upperBound >>;
+
+};
+/*
+ProtocolIE-Single-Container {X2AP-PROTOCOL-IES : IEsSetParam} ::=
+ ProtocolIE-Field {{IEsSetParam}}
+*/
+
+template<typename IEsSetParam>
+struct ProtocolIE_Single_Container : ProtocolIE_Field<IEsSetParam>
+{
+ static constexpr const char* name() {return "ProtocolIE-Single-Container";}
+ using parent_t = ProtocolIE_Field<IEsSetParam>;
+
+};
Code Review / sim / e2-interface.git / blobdiff