X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=sim%2Fe2-interface.git;a=blobdiff_plain;f=e2sim%2Fe2apv1sim%2Fricsim%2Fsrc%2FASN1%2Fgenerated%2FX2AP-Containers.hpp;fp=e2sim%2Fe2apv1sim%2Fricsim%2Fsrc%2FASN1%2Fgenerated%2FX2AP-Containers.hpp;h=09545bf1fe210303481e628095f4a36c41ddde65;hp=0000000000000000000000000000000000000000;hb=3ebf932d23dcbec9ed19f4a51f9d00a0a54f5124;hpb=6896318f2b4ff01b4a88b16019c3dc93b0b693f5 diff --git a/e2sim/e2apv1sim/ricsim/src/ASN1/generated/X2AP-Containers.hpp b/e2sim/e2apv1sim/ricsim/src/ASN1/generated/X2AP-Containers.hpp new file mode 100644 index 0000000..09545bf --- /dev/null +++ b/e2sim/e2apv1sim/ricsim/src/ASN1/generated/X2AP-Containers.hpp @@ -0,0 +1,700 @@ +/***************************************************************************** +# 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 +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 bool decode(V& v, PrivateIE_Field const& c) + { + return IEsSetParam::id_t::decode(v); + }; + template 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 bool decode(V& v, PrivateIE_Field const& c) + { + return IEsSetParam::criticality_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, PrivateIE_Field const& c) + { + return IEsSetParam::Value_t::decode(c.id.get_index(), v); + }; + template 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 void decode(V& v) + { + v(id); + v(criticality); + v(value); + + }; + template 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 +struct PrivateIE_Container_elm : PrivateIE_Field +{ + static constexpr const char* name() {return "PrivateIE_Container_elm";} + using parent_t = PrivateIE_Field; + +}; +template +struct PrivateIE_Container : asn::sequenceof > +{ + static constexpr const char* name() {return "PrivateIE-Container";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +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 +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 bool decode(V& v, ProtocolExtensionField const& c) + { + return ExtensionSetParam::id_t::decode(v); + }; + template 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 bool decode(V& v, ProtocolExtensionField const& c) + { + return ExtensionSetParam::criticality_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, ProtocolExtensionField const& c) + { + return ExtensionSetParam::Extension_t::decode(c.id.get_index(), v); + }; + template 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 void decode(V& v) + { + v(id); + v(criticality); + v(extensionValue); + + }; + template 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 +struct ProtocolExtensionContainer_elm : ProtocolExtensionField +{ + static constexpr const char* name() {return "ProtocolExtensionContainer_elm";} + using parent_t = ProtocolExtensionField; + +}; +template +struct ProtocolExtensionContainer : asn::sequenceof > +{ + static constexpr const char* name() {return "ProtocolExtensionContainer";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +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 +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 bool decode(V& v, ProtocolIE_Field const& c) + { + return IEsSetParam::id_t::decode(v); + }; + template 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 bool decode(V& v, ProtocolIE_Field const& c) + { + return IEsSetParam::criticality_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, ProtocolIE_Field const& c) + { + return IEsSetParam::Value_t::decode(c.id.get_index(), v); + }; + template 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 void decode(V& v) + { + v(id); + v(criticality); + v(value); + + }; + template 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 +struct ProtocolIE_Container_elm : ProtocolIE_Field +{ + static constexpr const char* name() {return "ProtocolIE_Container_elm";} + using parent_t = ProtocolIE_Field; + +}; +template +struct ProtocolIE_Container : asn::sequenceof > +{ + static constexpr const char* name() {return "ProtocolIE-Container";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +ProtocolIE-ContainerList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES : IEsSetParam} ::= + SEQUENCE (SIZE (lowerBound..upperBound)) OF + ProtocolIE-Container {{IEsSetParam}} +*/ + +template +struct ProtocolIE_ContainerList_elm : ProtocolIE_Container +{ + static constexpr const char* name() {return "ProtocolIE_ContainerList_elm";} + using parent_t = ProtocolIE_Container; + +}; +template +struct ProtocolIE_ContainerList : asn::sequenceof > +{ + static constexpr const char* name() {return "ProtocolIE-ContainerList";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +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 +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 bool decode(V& v, ProtocolIE_FieldPair const& c) + { + return IEsSetParam::id_t::decode(v); + }; + template 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 bool decode(V& v, ProtocolIE_FieldPair const& c) + { + return IEsSetParam::firstCriticality_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, ProtocolIE_FieldPair const& c) + { + return IEsSetParam::FirstValue_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, ProtocolIE_FieldPair const& c) + { + return IEsSetParam::secondCriticality_t::decode(c.id.get_index(), v); + }; + template 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 bool decode(V& v, ProtocolIE_FieldPair const& c) + { + return IEsSetParam::SecondValue_t::decode(c.id.get_index(), v); + }; + template 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 void decode(V& v) + { + v(id); + v(firstCriticality); + v(firstValue); + v(secondCriticality); + v(secondValue); + + }; + template 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 +struct ProtocolIE_ContainerPair_elm : ProtocolIE_FieldPair +{ + static constexpr const char* name() {return "ProtocolIE_ContainerPair_elm";} + using parent_t = ProtocolIE_FieldPair; + +}; +template +struct ProtocolIE_ContainerPair : asn::sequenceof > +{ + static constexpr const char* name() {return "ProtocolIE-ContainerPair";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +ProtocolIE-ContainerPairList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::= + SEQUENCE (SIZE (lowerBound..upperBound)) OF + ProtocolIE-ContainerPair {{IEsSetParam}} +*/ + +template +struct ProtocolIE_ContainerPairList_elm : ProtocolIE_ContainerPair +{ + static constexpr const char* name() {return "ProtocolIE_ContainerPairList_elm";} + using parent_t = ProtocolIE_ContainerPair; + +}; +template +struct ProtocolIE_ContainerPairList : asn::sequenceof > +{ + static constexpr const char* name() {return "ProtocolIE-ContainerPairList";} + using parent_t = asn::sequenceof >; + using constraint_t = asn::constraints>; + +}; +/* +ProtocolIE-Single-Container {X2AP-PROTOCOL-IES : IEsSetParam} ::= + ProtocolIE-Field {{IEsSetParam}} +*/ + +template +struct ProtocolIE_Single_Container : ProtocolIE_Field +{ + static constexpr const char* name() {return "ProtocolIE-Single-Container";} + using parent_t = ProtocolIE_Field; + +};