e2sim/e2apv1sim/src/ASN1/generated/X2AP-Containers.hpp

   1 /*****************************************************************************
   2 # Copyright 2019 AT&T Intellectual Property                                  *
   3 #                                                                            *
   4 # Licensed under the Apache License, Version 2.0 (the "License");            *
   5 # you may not use this file except in compliance with the License.           *
   6 # You may obtain a copy of the License at                                    *
   7 #                                                                            *
   8 #      http://www.apache.org/licenses/LICENSE-2.0                            *
   9 #                                                                            *
  10 # Unless required by applicable law or agreed to in writing, software        *
  11 # distributed under the License is distributed on an "AS IS" BASIS,          *
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
  13 # See the License for the specific language governing permissions and        *
  14 # limitations under the License.                                             *
  15 #                                                                            *
  16 ******************************************************************************/
  17
  18 #pragma once
  19
  20 #include "asn/asn.hpp"
  21 static_assert(ASN_API_VERSION_MAJOR == 5, "re-generate the ASN parser's code using 'make regen-asn' (do not use -j option)");
  22
  23 #include "X2AP-CommonDataTypes.hpp"
  24
  25 /*
  26 X2AP-PRIVATE-IES ::= CLASS {
  27         &id                                     PrivateIE-ID,
  28         &criticality            Criticality,
  29         &Value,
  30         &presence                       Presence
  31 }
  32 WITH SYNTAX {
  33         ID                                      &id
  34         CRITICALITY                     &criticality
  35         TYPE                            &Value
  36         PRESENCE                        &presence
  37 }
  38 */
  39
  40 struct X2AP_PRIVATE_IES
  41 {
  42         struct id_t : PrivateIE_ID
  43         {
  44                 static constexpr const char* name() {return "id_t";}
  45                 using parent_t = PrivateIE_ID;
  46
  47         };
  48         struct criticality_t : Criticality
  49         {
  50                 static constexpr const char* name() {return "criticality_t";}
  51                 using parent_t = Criticality;
  52
  53         };
  54         struct presence_t : Presence
  55         {
  56                 static constexpr const char* name() {return "presence_t";}
  57                 using parent_t = Presence;
  58
  59         };
  60
  61 };
  62 /*
  63 PrivateIE-Field {X2AP-PRIVATE-IES : IEsSetParam} ::= SEQUENCE {
  64         id                              X2AP-PRIVATE-IES.&id                    ({IEsSetParam}),
  65         criticality             X2AP-PRIVATE-IES.&criticality   ({IEsSetParam}{@id}),
  66         value                   X2AP-PRIVATE-IES.&Value                 ({IEsSetParam}{@id})
  67 }
  68 */
  69
  70 template<typename IEsSetParam>
  71 struct PrivateIE_Field : asn::sequence<3, 0, false, 0>
  72 {
  73         static constexpr const char* name() {return "PrivateIE-Field";}
  74         using parent_t = asn::sequence<3, 0, false, 0>;
  75         struct id_t : IEsSetParam::id_t
  76         {
  77                 static constexpr const char* name() {return "id_t";}
  78                 using parent_t = typename IEsSetParam::id_t;
  79                 template<typename V>  bool decode(V& v, PrivateIE_Field const& c)
  80                 {
  81                         return IEsSetParam::id_t::decode(v);
  82                 };
  83                 template<typename V>  bool encode(V& v, PrivateIE_Field const& c) const
  84                 {
  85                         return IEsSetParam::id_t::encode(v);
  86                 };
  87         };
  88         id_t& ref_id() {return id;}
  89         id_t const& ref_id() const {return id;}
  90         struct criticality_t : IEsSetParam::criticality_t
  91         {
  92                 static constexpr const char* name() {return "criticality_t";}
  93                 using parent_t = typename IEsSetParam::criticality_t;
  94                 template<typename V>  bool decode(V& v, PrivateIE_Field const& c)
  95                 {
  96                         return IEsSetParam::criticality_t::decode(c.id.get_index(), v);
  97                 };
  98                 template<typename V>  bool encode(V& v, PrivateIE_Field const& c) const
  99                 {
 100                         return IEsSetParam::criticality_t::encode(c.id.get_index(), v);
 101                 };
 102         };
 103         criticality_t& ref_criticality() {return criticality;}
 104         criticality_t const& ref_criticality() const {return criticality;}
 105         struct value_t : IEsSetParam::Value_t
 106         {
 107                 static constexpr const char* name() {return "value_t";}
 108                 using parent_t = typename IEsSetParam::Value_t;
 109                 template<typename V>  bool decode(V& v, PrivateIE_Field const& c)
 110                 {
 111                         return IEsSetParam::Value_t::decode(c.id.get_index(), v);
 112                 };
 113                 template<typename V>  bool encode(V& v, PrivateIE_Field const& c) const
 114                 {
 115                         return IEsSetParam::Value_t::encode(c.id.get_index(), v);
 116                 };
 117         };
 118         value_t& ref_value() {return value;}
 119         value_t const& ref_value() const {return value;}
 120         template<typename V> void decode(V& v)
 121         {
 122                 v(id);
 123                 v(criticality);
 124                 v(value);
 125
 126         };
 127         template<typename V> void encode(V& v) const
 128         {
 129                 v(id);
 130                 v(criticality);
 131                 v(value);
 132
 133         };
 134         void clear()
 135         {
 136                 id.clear();
 137                 criticality.clear();
 138                 value.clear();
 139
 140         };
 141         private:
 142         id_t    id;
 143         criticality_t   criticality;
 144         value_t value;
 145
 146 };
 147 /*
 148 PrivateIE-Container {X2AP-PRIVATE-IES : IEsSetParam} ::=
 149         SEQUENCE (SIZE (1..maxPrivateIEs)) OF
 150         PrivateIE-Field {{IEsSetParam}}
 151 */
 152
 153 template<typename IEsSetParam>
 154 struct PrivateIE_Container_elm : PrivateIE_Field<IEsSetParam>
 155 {
 156         static constexpr const char* name() {return "PrivateIE_Container_elm";}
 157         using parent_t = PrivateIE_Field<IEsSetParam>;
 158
 159 };
 160 template<typename IEsSetParam>
 161 struct PrivateIE_Container : asn::sequenceof<PrivateIE_Container_elm <IEsSetParam> >
 162 {
 163         static constexpr const char* name() {return "PrivateIE-Container";}
 164         using parent_t = asn::sequenceof<PrivateIE_Container_elm <IEsSetParam> >;
 165         using constraint_t = asn::constraints<false,asn::span<1,  maxPrivateIEs >>;
 166
 167 };
 168 /*
 169 X2AP-PROTOCOL-EXTENSION ::= CLASS {
 170         &id                                     ProtocolIE-ID           UNIQUE,
 171         &criticality            Criticality,
 172         &Extension,
 173         &presence                       Presence
 174 }
 175 WITH SYNTAX {
 176         ID                                      &id
 177         CRITICALITY                     &criticality
 178         EXTENSION                       &Extension
 179         PRESENCE                        &presence
 180 }
 181 */
 182
 183 struct X2AP_PROTOCOL_EXTENSION
 184 {
 185         struct id_t : ProtocolIE_ID
 186         {
 187                 static constexpr const char* name() {return "id_t";}
 188                 using parent_t = ProtocolIE_ID;
 189
 190         };
 191         struct criticality_t : Criticality
 192         {
 193                 static constexpr const char* name() {return "criticality_t";}
 194                 using parent_t = Criticality;
 195
 196         };
 197         struct presence_t : Presence
 198         {
 199                 static constexpr const char* name() {return "presence_t";}
 200                 using parent_t = Presence;
 201
 202         };
 203
 204 };
 205 /*
 206 ProtocolExtensionField {X2AP-PROTOCOL-EXTENSION : ExtensionSetParam} ::= SEQUENCE {
 207         id                                      X2AP-PROTOCOL-EXTENSION.&id                             ({ExtensionSetParam}),
 208         criticality                     X2AP-PROTOCOL-EXTENSION.&criticality    ({ExtensionSetParam}{@id}),
 209         extensionValue          X2AP-PROTOCOL-EXTENSION.&Extension              ({ExtensionSetParam}{@id})
 210 }
 211 */
 212
 213 template<typename ExtensionSetParam>
 214 struct ProtocolExtensionField : asn::sequence<3, 0, false, 0>
 215 {
 216         static constexpr const char* name() {return "ProtocolExtensionField";}
 217         using parent_t = asn::sequence<3, 0, false, 0>;
 218         struct id_t : ExtensionSetParam::id_t
 219         {
 220                 static constexpr const char* name() {return "id_t";}
 221                 using parent_t = typename ExtensionSetParam::id_t;
 222                 template<typename V>  bool decode(V& v, ProtocolExtensionField const& c)
 223                 {
 224                         return ExtensionSetParam::id_t::decode(v);
 225                 };
 226                 template<typename V>  bool encode(V& v, ProtocolExtensionField const& c) const
 227                 {
 228                         return ExtensionSetParam::id_t::encode(v);
 229                 };
 230         };
 231         id_t& ref_id() {return id;}
 232         id_t const& ref_id() const {return id;}
 233         struct criticality_t : ExtensionSetParam::criticality_t
 234         {
 235                 static constexpr const char* name() {return "criticality_t";}
 236                 using parent_t = typename ExtensionSetParam::criticality_t;
 237                 template<typename V>  bool decode(V& v, ProtocolExtensionField const& c)
 238                 {
 239                         return ExtensionSetParam::criticality_t::decode(c.id.get_index(), v);
 240                 };
 241                 template<typename V>  bool encode(V& v, ProtocolExtensionField const& c) const
 242                 {
 243                         return ExtensionSetParam::criticality_t::encode(c.id.get_index(), v);
 244                 };
 245         };
 246         criticality_t& ref_criticality() {return criticality;}
 247         criticality_t const& ref_criticality() const {return criticality;}
 248         struct extensionValue_t : ExtensionSetParam::Extension_t
 249         {
 250                 static constexpr const char* name() {return "extensionValue_t";}
 251                 using parent_t = typename ExtensionSetParam::Extension_t;
 252                 template<typename V>  bool decode(V& v, ProtocolExtensionField const& c)
 253                 {
 254                         return ExtensionSetParam::Extension_t::decode(c.id.get_index(), v);
 255                 };
 256                 template<typename V>  bool encode(V& v, ProtocolExtensionField const& c) const
 257                 {
 258                         return ExtensionSetParam::Extension_t::encode(c.id.get_index(), v);
 259                 };
 260         };
 261         extensionValue_t& ref_extensionValue() {return extensionValue;}
 262         extensionValue_t const& ref_extensionValue() const {return extensionValue;}
 263         template<typename V> void decode(V& v)
 264         {
 265                 v(id);
 266                 v(criticality);
 267                 v(extensionValue);
 268
 269         };
 270         template<typename V> void encode(V& v) const
 271         {
 272                 v(id);
 273                 v(criticality);
 274                 v(extensionValue);
 275
 276         };
 277         void clear()
 278         {
 279                 id.clear();
 280                 criticality.clear();
 281                 extensionValue.clear();
 282
 283         };
 284         private:
 285         id_t    id;
 286         criticality_t   criticality;
 287         extensionValue_t        extensionValue;
 288
 289 };
 290 /*
 291 ProtocolExtensionContainer {X2AP-PROTOCOL-EXTENSION : ExtensionSetParam} ::=
 292         SEQUENCE (SIZE (1..maxProtocolExtensions)) OF
 293         ProtocolExtensionField {{ExtensionSetParam}}
 294 */
 295
 296 template<typename ExtensionSetParam>
 297 struct ProtocolExtensionContainer_elm : ProtocolExtensionField<ExtensionSetParam>
 298 {
 299         static constexpr const char* name() {return "ProtocolExtensionContainer_elm";}
 300         using parent_t = ProtocolExtensionField<ExtensionSetParam>;
 301
 302 };
 303 template<typename ExtensionSetParam>
 304 struct ProtocolExtensionContainer : asn::sequenceof<ProtocolExtensionContainer_elm <ExtensionSetParam> >
 305 {
 306         static constexpr const char* name() {return "ProtocolExtensionContainer";}
 307         using parent_t = asn::sequenceof<ProtocolExtensionContainer_elm <ExtensionSetParam> >;
 308         using constraint_t = asn::constraints<false,asn::span<1,  maxProtocolExtensions >>;
 309
 310 };
 311 /*
 312 X2AP-PROTOCOL-IES ::= CLASS {
 313         &id                             ProtocolIE-ID                   UNIQUE,
 314         &criticality    Criticality,
 315         &Value,
 316         &presence               Presence
 317 }
 318 WITH SYNTAX {
 319         ID                              &id
 320         CRITICALITY             &criticality
 321         TYPE                    &Value
 322         PRESENCE                &presence
 323 }
 324 */
 325
 326 struct X2AP_PROTOCOL_IES
 327 {
 328         struct id_t : ProtocolIE_ID
 329         {
 330                 static constexpr const char* name() {return "id_t";}
 331                 using parent_t = ProtocolIE_ID;
 332
 333         };
 334         struct criticality_t : Criticality
 335         {
 336                 static constexpr const char* name() {return "criticality_t";}
 337                 using parent_t = Criticality;
 338
 339         };
 340         struct presence_t : Presence
 341         {
 342                 static constexpr const char* name() {return "presence_t";}
 343                 using parent_t = Presence;
 344
 345         };
 346
 347 };
 348 /*
 349 ProtocolIE-Field {X2AP-PROTOCOL-IES : IEsSetParam} ::= SEQUENCE {
 350         id                              X2AP-PROTOCOL-IES.&id                                   ({IEsSetParam}),
 351         criticality             X2AP-PROTOCOL-IES.&criticality                  ({IEsSetParam}{@id}),
 352         value                   X2AP-PROTOCOL-IES.&Value                                ({IEsSetParam}{@id})
 353 }
 354 */
 355
 356 template<typename IEsSetParam>
 357 struct ProtocolIE_Field : asn::sequence<3, 0, false, 0>
 358 {
 359         static constexpr const char* name() {return "ProtocolIE-Field";}
 360         using parent_t = asn::sequence<3, 0, false, 0>;
 361         struct id_t : IEsSetParam::id_t
 362         {
 363                 static constexpr const char* name() {return "id_t";}
 364                 using parent_t = typename IEsSetParam::id_t;
 365                 template<typename V>  bool decode(V& v, ProtocolIE_Field const& c)
 366                 {
 367                         return IEsSetParam::id_t::decode(v);
 368                 };
 369                 template<typename V>  bool encode(V& v, ProtocolIE_Field const& c) const
 370                 {
 371                         return IEsSetParam::id_t::encode(v);
 372                 };
 373         };
 374         id_t& ref_id() {return id;}
 375         id_t const& ref_id() const {return id;}
 376         struct criticality_t : IEsSetParam::criticality_t
 377         {
 378                 static constexpr const char* name() {return "criticality_t";}
 379                 using parent_t = typename IEsSetParam::criticality_t;
 380                 template<typename V>  bool decode(V& v, ProtocolIE_Field const& c)
 381                 {
 382                         return IEsSetParam::criticality_t::decode(c.id.get_index(), v);
 383                 };
 384                 template<typename V>  bool encode(V& v, ProtocolIE_Field const& c) const
 385                 {
 386                         return IEsSetParam::criticality_t::encode(c.id.get_index(), v);
 387                 };
 388         };
 389         criticality_t& ref_criticality() {return criticality;}
 390         criticality_t const& ref_criticality() const {return criticality;}
 391         struct value_t : IEsSetParam::Value_t
 392         {
 393                 static constexpr const char* name() {return "value_t";}
 394                 using parent_t = typename IEsSetParam::Value_t;
 395                 template<typename V>  bool decode(V& v, ProtocolIE_Field const& c)
 396                 {
 397                         return IEsSetParam::Value_t::decode(c.id.get_index(), v);
 398                 };
 399                 template<typename V>  bool encode(V& v, ProtocolIE_Field const& c) const
 400                 {
 401                         return IEsSetParam::Value_t::encode(c.id.get_index(), v);
 402                 };
 403         };
 404         value_t& ref_value() {return value;}
 405         value_t const& ref_value() const {return value;}
 406         template<typename V> void decode(V& v)
 407         {
 408                 v(id);
 409                 v(criticality);
 410                 v(value);
 411
 412         };
 413         template<typename V> void encode(V& v) const
 414         {
 415                 v(id);
 416                 v(criticality);
 417                 v(value);
 418
 419         };
 420         void clear()
 421         {
 422                 id.clear();
 423                 criticality.clear();
 424                 value.clear();
 425
 426         };
 427         private:
 428         id_t    id;
 429         criticality_t   criticality;
 430         value_t value;
 431
 432 };
 433 /*
 434 ProtocolIE-Container {X2AP-PROTOCOL-IES : IEsSetParam} ::=
 435         SEQUENCE (SIZE (0..maxProtocolIEs)) OF
 436         ProtocolIE-Field {{IEsSetParam}}
 437 */
 438
 439 template<typename IEsSetParam>
 440 struct ProtocolIE_Container_elm : ProtocolIE_Field<IEsSetParam>
 441 {
 442         static constexpr const char* name() {return "ProtocolIE_Container_elm";}
 443         using parent_t = ProtocolIE_Field<IEsSetParam>;
 444
 445 };
 446 template<typename IEsSetParam>
 447 struct ProtocolIE_Container : asn::sequenceof<ProtocolIE_Container_elm <IEsSetParam> >
 448 {
 449         static constexpr const char* name() {return "ProtocolIE-Container";}
 450         using parent_t = asn::sequenceof<ProtocolIE_Container_elm <IEsSetParam> >;
 451         using constraint_t = asn::constraints<false,asn::span<0,  maxProtocolIEs >>;
 452
 453 };
 454 /*
 455 ProtocolIE-ContainerList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES : IEsSetParam} ::=
 456         SEQUENCE (SIZE (lowerBound..upperBound)) OF
 457         ProtocolIE-Container {{IEsSetParam}}
 458 */
 459
 460 template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
 461 struct ProtocolIE_ContainerList_elm : ProtocolIE_Container<IEsSetParam>
 462 {
 463         static constexpr const char* name() {return "ProtocolIE_ContainerList_elm";}
 464         using parent_t = ProtocolIE_Container<IEsSetParam>;
 465
 466 };
 467 template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
 468 struct ProtocolIE_ContainerList : asn::sequenceof<ProtocolIE_ContainerList_elm <lowerBound, upperBound, IEsSetParam> >
 469 {
 470         static constexpr const char* name() {return "ProtocolIE-ContainerList";}
 471         using parent_t = asn::sequenceof<ProtocolIE_ContainerList_elm <lowerBound, upperBound, IEsSetParam> >;
 472         using constraint_t = asn::constraints<false,asn::span< lowerBound ,  upperBound >>;
 473
 474 };
 475 /*
 476 X2AP-PROTOCOL-IES-PAIR ::= CLASS {
 477         &id                                             ProtocolIE-ID           UNIQUE,
 478         &firstCriticality               Criticality,
 479         &FirstValue,
 480         &secondCriticality              Criticality,
 481         &SecondValue,
 482         &presence                               Presence
 483 }
 484 WITH SYNTAX {
 485         ID                                              &id
 486         FIRST CRITICALITY               &firstCriticality
 487         FIRST TYPE                              &FirstValue
 488         SECOND CRITICALITY              &secondCriticality
 489         SECOND TYPE                             &SecondValue
 490         PRESENCE                                &presence
 491 }
 492 */
 493
 494 struct X2AP_PROTOCOL_IES_PAIR
 495 {
 496         struct id_t : ProtocolIE_ID
 497         {
 498                 static constexpr const char* name() {return "id_t";}
 499                 using parent_t = ProtocolIE_ID;
 500
 501         };
 502         struct firstCriticality_t : Criticality
 503         {
 504                 static constexpr const char* name() {return "firstCriticality_t";}
 505                 using parent_t = Criticality;
 506
 507         };
 508         struct secondCriticality_t : Criticality
 509         {
 510                 static constexpr const char* name() {return "secondCriticality_t";}
 511                 using parent_t = Criticality;
 512
 513         };
 514         struct presence_t : Presence
 515         {
 516                 static constexpr const char* name() {return "presence_t";}
 517                 using parent_t = Presence;
 518
 519         };
 520
 521 };
 522 /*
 523 ProtocolIE-FieldPair {X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::= SEQUENCE {
 524         id                                      X2AP-PROTOCOL-IES-PAIR.&id                                      ({IEsSetParam}),
 525         firstCriticality        X2AP-PROTOCOL-IES-PAIR.&firstCriticality        ({IEsSetParam}{@id}),
 526         firstValue                      X2AP-PROTOCOL-IES-PAIR.&FirstValue                      ({IEsSetParam}{@id}),
 527         secondCriticality       X2AP-PROTOCOL-IES-PAIR.&secondCriticality       ({IEsSetParam}{@id}),
 528         secondValue                     X2AP-PROTOCOL-IES-PAIR.&SecondValue                     ({IEsSetParam}{@id})
 529 }
 530 */
 531
 532 template<typename IEsSetParam>
 533 struct ProtocolIE_FieldPair : asn::sequence<5, 0, false, 0>
 534 {
 535         static constexpr const char* name() {return "ProtocolIE-FieldPair";}
 536         using parent_t = asn::sequence<5, 0, false, 0>;
 537         struct id_t : IEsSetParam::id_t
 538         {
 539                 static constexpr const char* name() {return "id_t";}
 540                 using parent_t = typename IEsSetParam::id_t;
 541                 template<typename V>  bool decode(V& v, ProtocolIE_FieldPair const& c)
 542                 {
 543                         return IEsSetParam::id_t::decode(v);
 544                 };
 545                 template<typename V>  bool encode(V& v, ProtocolIE_FieldPair const& c) const
 546                 {
 547                         return IEsSetParam::id_t::encode(v);
 548                 };
 549         };
 550         id_t& ref_id() {return id;}
 551         id_t const& ref_id() const {return id;}
 552         struct firstCriticality_t : IEsSetParam::firstCriticality_t
 553         {
 554                 static constexpr const char* name() {return "firstCriticality_t";}
 555                 using parent_t = typename IEsSetParam::firstCriticality_t;
 556                 template<typename V>  bool decode(V& v, ProtocolIE_FieldPair const& c)
 557                 {
 558                         return IEsSetParam::firstCriticality_t::decode(c.id.get_index(), v);
 559                 };
 560                 template<typename V>  bool encode(V& v, ProtocolIE_FieldPair const& c) const
 561                 {
 562                         return IEsSetParam::firstCriticality_t::encode(c.id.get_index(), v);
 563                 };
 564         };
 565         firstCriticality_t& ref_firstCriticality() {return firstCriticality;}
 566         firstCriticality_t const& ref_firstCriticality() const {return firstCriticality;}
 567         struct firstValue_t : IEsSetParam::FirstValue_t
 568         {
 569                 static constexpr const char* name() {return "firstValue_t";}
 570                 using parent_t = typename IEsSetParam::FirstValue_t;
 571                 template<typename V>  bool decode(V& v, ProtocolIE_FieldPair const& c)
 572                 {
 573                         return IEsSetParam::FirstValue_t::decode(c.id.get_index(), v);
 574                 };
 575                 template<typename V>  bool encode(V& v, ProtocolIE_FieldPair const& c) const
 576                 {
 577                         return IEsSetParam::FirstValue_t::encode(c.id.get_index(), v);
 578                 };
 579         };
 580         firstValue_t& ref_firstValue() {return firstValue;}
 581         firstValue_t const& ref_firstValue() const {return firstValue;}
 582         struct secondCriticality_t : IEsSetParam::secondCriticality_t
 583         {
 584                 static constexpr const char* name() {return "secondCriticality_t";}
 585                 using parent_t = typename IEsSetParam::secondCriticality_t;
 586                 template<typename V>  bool decode(V& v, ProtocolIE_FieldPair const& c)
 587                 {
 588                         return IEsSetParam::secondCriticality_t::decode(c.id.get_index(), v);
 589                 };
 590                 template<typename V>  bool encode(V& v, ProtocolIE_FieldPair const& c) const
 591                 {
 592                         return IEsSetParam::secondCriticality_t::encode(c.id.get_index(), v);
 593                 };
 594         };
 595         secondCriticality_t& ref_secondCriticality() {return secondCriticality;}
 596         secondCriticality_t const& ref_secondCriticality() const {return secondCriticality;}
 597         struct secondValue_t : IEsSetParam::SecondValue_t
 598         {
 599                 static constexpr const char* name() {return "secondValue_t";}
 600                 using parent_t = typename IEsSetParam::SecondValue_t;
 601                 template<typename V>  bool decode(V& v, ProtocolIE_FieldPair const& c)
 602                 {
 603                         return IEsSetParam::SecondValue_t::decode(c.id.get_index(), v);
 604                 };
 605                 template<typename V>  bool encode(V& v, ProtocolIE_FieldPair const& c) const
 606                 {
 607                         return IEsSetParam::SecondValue_t::encode(c.id.get_index(), v);
 608                 };
 609         };
 610         secondValue_t& ref_secondValue() {return secondValue;}
 611         secondValue_t const& ref_secondValue() const {return secondValue;}
 612         template<typename V> void decode(V& v)
 613         {
 614                 v(id);
 615                 v(firstCriticality);
 616                 v(firstValue);
 617                 v(secondCriticality);
 618                 v(secondValue);
 619
 620         };
 621         template<typename V> void encode(V& v) const
 622         {
 623                 v(id);
 624                 v(firstCriticality);
 625                 v(firstValue);
 626                 v(secondCriticality);
 627                 v(secondValue);
 628
 629         };
 630         void clear()
 631         {
 632                 id.clear();
 633                 firstCriticality.clear();
 634                 firstValue.clear();
 635                 secondCriticality.clear();
 636                 secondValue.clear();
 637
 638         };
 639         private:
 640         id_t    id;
 641         firstCriticality_t      firstCriticality;
 642         firstValue_t    firstValue;
 643         secondCriticality_t     secondCriticality;
 644         secondValue_t   secondValue;
 645
 646 };
 647 /*
 648 ProtocolIE-ContainerPair {X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::=
 649         SEQUENCE (SIZE (0..maxProtocolIEs)) OF
 650         ProtocolIE-FieldPair {{IEsSetParam}}
 651 */
 652
 653 template<typename IEsSetParam>
 654 struct ProtocolIE_ContainerPair_elm : ProtocolIE_FieldPair<IEsSetParam>
 655 {
 656         static constexpr const char* name() {return "ProtocolIE_ContainerPair_elm";}
 657         using parent_t = ProtocolIE_FieldPair<IEsSetParam>;
 658
 659 };
 660 template<typename IEsSetParam>
 661 struct ProtocolIE_ContainerPair : asn::sequenceof<ProtocolIE_ContainerPair_elm <IEsSetParam> >
 662 {
 663         static constexpr const char* name() {return "ProtocolIE-ContainerPair";}
 664         using parent_t = asn::sequenceof<ProtocolIE_ContainerPair_elm <IEsSetParam> >;
 665         using constraint_t = asn::constraints<false,asn::span<0,  maxProtocolIEs >>;
 666
 667 };
 668 /*
 669 ProtocolIE-ContainerPairList {INTEGER : lowerBound, INTEGER : upperBound, X2AP-PROTOCOL-IES-PAIR : IEsSetParam} ::=
 670         SEQUENCE (SIZE (lowerBound..upperBound)) OF
 671         ProtocolIE-ContainerPair {{IEsSetParam}}
 672 */
 673
 674 template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
 675 struct ProtocolIE_ContainerPairList_elm : ProtocolIE_ContainerPair<IEsSetParam>
 676 {
 677         static constexpr const char* name() {return "ProtocolIE_ContainerPairList_elm";}
 678         using parent_t = ProtocolIE_ContainerPair<IEsSetParam>;
 679
 680 };
 681 template<int64_t lowerBound, int64_t upperBound, typename IEsSetParam>
 682 struct ProtocolIE_ContainerPairList : asn::sequenceof<ProtocolIE_ContainerPairList_elm <lowerBound, upperBound, IEsSetParam> >
 683 {
 684         static constexpr const char* name() {return "ProtocolIE-ContainerPairList";}
 685         using parent_t = asn::sequenceof<ProtocolIE_ContainerPairList_elm <lowerBound, upperBound, IEsSetParam> >;
 686         using constraint_t = asn::constraints<false,asn::span< lowerBound ,  upperBound >>;
 687
 688 };
 689 /*
 690 ProtocolIE-Single-Container {X2AP-PROTOCOL-IES : IEsSetParam} ::=
 691         ProtocolIE-Field {{IEsSetParam}}
 692 */
 693
 694 template<typename IEsSetParam>
 695 struct ProtocolIE_Single_Container : ProtocolIE_Field<IEsSetParam>
 696 {
 697         static constexpr const char* name() {return "ProtocolIE-Single-Container";}
 698         using parent_t = ProtocolIE_Field<IEsSetParam>;
 699
 700 };