e2sim/e2apv1sim/src/ASN1/generated/X2AP-PDU-Contents.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-IEs.hpp"
  24 #include "X2AP-Containers.hpp"
  25 #include "X2AP-Constants.hpp"
  26
  27 /*
  28 ActivatedCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
  29         ...
  30 }
  31 */
  32
  33 struct ActivatedCellList_Item_ExtIEs
  34 {
  35         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
  36         {
  37                 size_t get_index() const {return type;}
  38                 bool is_unknown() const { return type == 1; }
  39                 void clear() {type = 0;}
  40                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
  41                 template<typename V>  bool decode(V& v)
  42                 {
  43                         clear();
  44                         if(!v(ref_nested())) return false;
  45                         { type = 1; return true;}
  46                         return false;
  47
  48                 }
  49                 template<typename V> bool encode(V& v) const
  50                 {
  51                         return v(ref_nested());
  52
  53                 }
  54                 protected:
  55                 template<typename V>  bool decode(size_t index, V& v)
  56                 {
  57                         clear();
  58                         switch(index)
  59                         {
  60                         case 1: type = 1; return v(ref_nested());
  61                         ref_nested().clear();
  62                         }
  63                         return false;
  64
  65                 }
  66                 template<typename V> bool encode(size_t index, V& v) const
  67                 {
  68                         if(index != type) {return false;} return v(ref_nested());
  69
  70                 }
  71                 private:
  72                 size_t type {0};
  73
  74         };
  75         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
  76         {
  77                 size_t get_index() const {return type;}
  78                 bool is_unknown() const { return type == 1; }
  79                 void clear() {type = 0;}
  80                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
  81                 template<typename V>  bool decode(V& v)
  82                 {
  83                         clear();
  84                         if(!v(ref_nested())) return false;
  85                         { type = 1; return true;}
  86                         return false;
  87
  88                 }
  89                 template<typename V> bool encode(V& v) const
  90                 {
  91                         return v(ref_nested());
  92
  93                 }
  94                 protected:
  95                 template<typename V>  bool decode(size_t index, V& v)
  96                 {
  97                         clear();
  98                         switch(index)
  99                         {
 100                         case 1: type = 1; return v(ref_nested());
 101                         ref_nested().clear();
 102                         }
 103                         return false;
 104
 105                 }
 106                 template<typename V> bool encode(size_t index, V& v) const
 107                 {
 108                         if(index != type) {return false;} return v(ref_nested());
 109
 110                 }
 111                 private:
 112                 size_t type {0};
 113
 114         };
 115         struct Extension_t : asn::typefield<true>
 116         {
 117                 ~Extension_t()  {clear();}
 118                 size_t get_index() const {return type;}
 119                 bool is_unknown() const { return type == 1; }
 120                 void clear()
 121                 {
 122                         type = 0; ref_nested().clear();
 123                 }
 124                 template<typename V> static inline void enumerate(V& v)
 125                 {
 126
 127                 }
 128                 protected:
 129                 template<typename V> bool decode(size_t index, V& v)
 130                 {
 131                         clear();
 132                         switch(index)
 133                         {
 134                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 135                         }
 136                         return false;
 137
 138                 }
 139                 template<typename V> bool encode(size_t index, V& v) const
 140                 {
 141                         if(index != type) return false;
 142                         return false;
 143
 144                 }
 145                 private:
 146                 size_t type {0};
 147
 148         };
 149         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 150         {
 151                 size_t get_index() const {return type;}
 152                 bool is_unknown() const { return type == 1; }
 153                 void clear() {type = 0;}
 154                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 155                 template<typename V>  bool decode(V& v)
 156                 {
 157                         clear();
 158                         if(!v(ref_nested())) return false;
 159                         { type = 1; return true;}
 160                         return false;
 161
 162                 }
 163                 template<typename V> bool encode(V& v) const
 164                 {
 165                         return v(ref_nested());
 166
 167                 }
 168                 protected:
 169                 template<typename V>  bool decode(size_t index, V& v)
 170                 {
 171                         clear();
 172                         switch(index)
 173                         {
 174                         case 1: type = 1; return v(ref_nested());
 175                         ref_nested().clear();
 176                         }
 177                         return false;
 178
 179                 }
 180                 template<typename V> bool encode(size_t index, V& v) const
 181                 {
 182                         if(index != type) {return false;} return v(ref_nested());
 183
 184                 }
 185                 private:
 186                 size_t type {0};
 187
 188         };
 189
 190 };
 191 /*
 192 ActivatedCellList-Item::= SEQUENCE {
 193         ecgi                                                            ECGI,
 194         iE-Extensions                                           ProtocolExtensionContainer { {ActivatedCellList-Item-ExtIEs} } OPTIONAL,
 195         ...
 196 }
 197 */
 198
 199 struct ActivatedCellList_Item : asn::sequence<2, 0, true, 1>
 200 {
 201         static constexpr const char* name() {return "ActivatedCellList-Item";}
 202         using parent_t = asn::sequence<2, 0, true, 1>;
 203         struct ecgi_t : ECGI
 204         {
 205                 static constexpr const char* name() {return "ecgi_t";}
 206                 using parent_t = ECGI;
 207
 208         };
 209         ecgi_t& ref_ecgi() {return ecgi;}
 210         ecgi_t const& ref_ecgi() const {return ecgi;}
 211         struct iE_Extensions_t : ProtocolExtensionContainer<ActivatedCellList_Item_ExtIEs>
 212         {
 213                 static constexpr const char* name() {return "iE_Extensions_t";}
 214                 using parent_t = ProtocolExtensionContainer<ActivatedCellList_Item_ExtIEs>;
 215                 static constexpr bool optional = true;
 216
 217         };
 218         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 219         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 220         template<typename V> void decode(V& v)
 221         {
 222                 v(ecgi);
 223                 v(iE_Extensions);
 224
 225         };
 226         template<typename V> void encode(V& v) const
 227         {
 228                 v(ecgi);
 229                 v(iE_Extensions);
 230
 231         };
 232         void clear()
 233         {
 234                 ecgi.clear();
 235                 iE_Extensions.clear();
 236
 237         };
 238         private:
 239         ecgi_t  ecgi;
 240         iE_Extensions_t iE_Extensions;
 241
 242 };
 243 /*
 244 ActivatedCellList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ActivatedCellList-Item
 245 */
 246
 247 struct ActivatedCellList_elm : ActivatedCellList_Item
 248 {
 249         static constexpr const char* name() {return "ActivatedCellList_elm";}
 250         using parent_t = ActivatedCellList_Item;
 251
 252 };
 253 struct ActivatedCellList : asn::sequenceof<ActivatedCellList_elm>
 254 {
 255         static constexpr const char* name() {return "ActivatedCellList";}
 256         using parent_t = asn::sequenceof<ActivatedCellList_elm>;
 257         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
 258
 259 };
 260 /*
 261 ActivatedNRCellList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
 262         ...
 263 }
 264 */
 265
 266 struct ActivatedNRCellList_Item_ExtIEs
 267 {
 268         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
 269         {
 270                 size_t get_index() const {return type;}
 271                 bool is_unknown() const { return type == 1; }
 272                 void clear() {type = 0;}
 273                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
 274                 template<typename V>  bool decode(V& v)
 275                 {
 276                         clear();
 277                         if(!v(ref_nested())) return false;
 278                         { type = 1; return true;}
 279                         return false;
 280
 281                 }
 282                 template<typename V> bool encode(V& v) const
 283                 {
 284                         return v(ref_nested());
 285
 286                 }
 287                 protected:
 288                 template<typename V>  bool decode(size_t index, V& v)
 289                 {
 290                         clear();
 291                         switch(index)
 292                         {
 293                         case 1: type = 1; return v(ref_nested());
 294                         ref_nested().clear();
 295                         }
 296                         return false;
 297
 298                 }
 299                 template<typename V> bool encode(size_t index, V& v) const
 300                 {
 301                         if(index != type) {return false;} return v(ref_nested());
 302
 303                 }
 304                 private:
 305                 size_t type {0};
 306
 307         };
 308         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
 309         {
 310                 size_t get_index() const {return type;}
 311                 bool is_unknown() const { return type == 1; }
 312                 void clear() {type = 0;}
 313                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
 314                 template<typename V>  bool decode(V& v)
 315                 {
 316                         clear();
 317                         if(!v(ref_nested())) return false;
 318                         { type = 1; return true;}
 319                         return false;
 320
 321                 }
 322                 template<typename V> bool encode(V& v) const
 323                 {
 324                         return v(ref_nested());
 325
 326                 }
 327                 protected:
 328                 template<typename V>  bool decode(size_t index, V& v)
 329                 {
 330                         clear();
 331                         switch(index)
 332                         {
 333                         case 1: type = 1; return v(ref_nested());
 334                         ref_nested().clear();
 335                         }
 336                         return false;
 337
 338                 }
 339                 template<typename V> bool encode(size_t index, V& v) const
 340                 {
 341                         if(index != type) {return false;} return v(ref_nested());
 342
 343                 }
 344                 private:
 345                 size_t type {0};
 346
 347         };
 348         struct Extension_t : asn::typefield<true>
 349         {
 350                 ~Extension_t()  {clear();}
 351                 size_t get_index() const {return type;}
 352                 bool is_unknown() const { return type == 1; }
 353                 void clear()
 354                 {
 355                         type = 0; ref_nested().clear();
 356                 }
 357                 template<typename V> static inline void enumerate(V& v)
 358                 {
 359
 360                 }
 361                 protected:
 362                 template<typename V> bool decode(size_t index, V& v)
 363                 {
 364                         clear();
 365                         switch(index)
 366                         {
 367                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 368                         }
 369                         return false;
 370
 371                 }
 372                 template<typename V> bool encode(size_t index, V& v) const
 373                 {
 374                         if(index != type) return false;
 375                         return false;
 376
 377                 }
 378                 private:
 379                 size_t type {0};
 380
 381         };
 382         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 383         {
 384                 size_t get_index() const {return type;}
 385                 bool is_unknown() const { return type == 1; }
 386                 void clear() {type = 0;}
 387                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 388                 template<typename V>  bool decode(V& v)
 389                 {
 390                         clear();
 391                         if(!v(ref_nested())) return false;
 392                         { type = 1; return true;}
 393                         return false;
 394
 395                 }
 396                 template<typename V> bool encode(V& v) const
 397                 {
 398                         return v(ref_nested());
 399
 400                 }
 401                 protected:
 402                 template<typename V>  bool decode(size_t index, V& v)
 403                 {
 404                         clear();
 405                         switch(index)
 406                         {
 407                         case 1: type = 1; return v(ref_nested());
 408                         ref_nested().clear();
 409                         }
 410                         return false;
 411
 412                 }
 413                 template<typename V> bool encode(size_t index, V& v) const
 414                 {
 415                         if(index != type) {return false;} return v(ref_nested());
 416
 417                 }
 418                 private:
 419                 size_t type {0};
 420
 421         };
 422
 423 };
 424 /*
 425 ActivatedNRCellList-Item::= SEQUENCE {
 426         nrCellID                                                NRCGI,
 427         iE-Extensions                                           ProtocolExtensionContainer { {ActivatedNRCellList-Item-ExtIEs} } OPTIONAL,
 428         ...
 429 }
 430 */
 431
 432 struct ActivatedNRCellList_Item : asn::sequence<2, 0, true, 1>
 433 {
 434         static constexpr const char* name() {return "ActivatedNRCellList-Item";}
 435         using parent_t = asn::sequence<2, 0, true, 1>;
 436         struct nrCellID_t : NRCGI
 437         {
 438                 static constexpr const char* name() {return "nrCellID_t";}
 439                 using parent_t = NRCGI;
 440
 441         };
 442         nrCellID_t& ref_nrCellID() {return nrCellID;}
 443         nrCellID_t const& ref_nrCellID() const {return nrCellID;}
 444         struct iE_Extensions_t : ProtocolExtensionContainer<ActivatedNRCellList_Item_ExtIEs>
 445         {
 446                 static constexpr const char* name() {return "iE_Extensions_t";}
 447                 using parent_t = ProtocolExtensionContainer<ActivatedNRCellList_Item_ExtIEs>;
 448                 static constexpr bool optional = true;
 449
 450         };
 451         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 452         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 453         template<typename V> void decode(V& v)
 454         {
 455                 v(nrCellID);
 456                 v(iE_Extensions);
 457
 458         };
 459         template<typename V> void encode(V& v) const
 460         {
 461                 v(nrCellID);
 462                 v(iE_Extensions);
 463
 464         };
 465         void clear()
 466         {
 467                 nrCellID.clear();
 468                 iE_Extensions.clear();
 469
 470         };
 471         private:
 472         nrCellID_t      nrCellID;
 473         iE_Extensions_t iE_Extensions;
 474
 475 };
 476 /*
 477 ActivatedNRCellList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ActivatedNRCellList-Item
 478 */
 479
 480 struct ActivatedNRCellList_elm : ActivatedNRCellList_Item
 481 {
 482         static constexpr const char* name() {return "ActivatedNRCellList_elm";}
 483         using parent_t = ActivatedNRCellList_Item;
 484
 485 };
 486 struct ActivatedNRCellList : asn::sequenceof<ActivatedNRCellList_elm>
 487 {
 488         static constexpr const char* name() {return "ActivatedNRCellList";}
 489         using parent_t = asn::sequenceof<ActivatedNRCellList_elm>;
 490         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
 491
 492 };
 493 /*
 494 CellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
 495         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory }|
 496         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional },
 497         ...
 498 }
 499 */
 500
 501 struct CellActivationFailure_IEs
 502 {
 503         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
 504         {
 505                 size_t get_index() const {return type;}
 506                 bool is_unknown() const { return type == 3; }
 507                 void clear() {type = 0;}
 508                 void select_id_Cause() { set(id_Cause); type=1;}
 509                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
 510                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
 511                 template<typename V>  bool decode(V& v)
 512                 {
 513                         clear();
 514                         if(!v(ref_nested())) return false;
 515                         if(equal(id_Cause)) { type = 1; return true; }
 516                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
 517                         else { type = 3; return true;}
 518                         return false;
 519
 520                 }
 521                 template<typename V> bool encode(V& v) const
 522                 {
 523                         return v(ref_nested());
 524
 525                 }
 526                 protected:
 527                 template<typename V>  bool decode(size_t index, V& v)
 528                 {
 529                         clear();
 530                         switch(index)
 531                         {
 532                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
 533                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
 534                         case 3: type = 3; return v(ref_nested());
 535                         ref_nested().clear();
 536                         }
 537                         return false;
 538
 539                 }
 540                 template<typename V> bool encode(size_t index, V& v) const
 541                 {
 542                         if(index != type) {return false;} return v(ref_nested());
 543
 544                 }
 545                 private:
 546                 size_t type {0};
 547
 548         };
 549         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
 550         {
 551                 size_t get_index() const {return type;}
 552                 bool is_unknown() const { return type == 3; }
 553                 void clear() {type = 0;}
 554                 void select_id_Cause() { set(ignore); type=1;}
 555                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
 556                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
 557                 template<typename V>  bool decode(V& v)
 558                 {
 559                         clear();
 560                         if(!v(ref_nested())) return false;
 561                         if(equal(ignore)) { type = 1; return true; }
 562                         else if(equal(ignore)) { type = 2; return true; }
 563                         else { type = 3; return true;}
 564                         return false;
 565
 566                 }
 567                 template<typename V> bool encode(V& v) const
 568                 {
 569                         return v(ref_nested());
 570
 571                 }
 572                 protected:
 573                 template<typename V>  bool decode(size_t index, V& v)
 574                 {
 575                         clear();
 576                         switch(index)
 577                         {
 578                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
 579                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
 580                         case 3: type = 3; return v(ref_nested());
 581                         ref_nested().clear();
 582                         }
 583                         return false;
 584
 585                 }
 586                 template<typename V> bool encode(size_t index, V& v) const
 587                 {
 588                         if(index != type) {return false;} return v(ref_nested());
 589
 590                 }
 591                 private:
 592                 size_t type {0};
 593
 594         };
 595         struct Value_t : asn::typefield<true>
 596         {
 597                 ~Value_t()      {clear();}
 598                 size_t get_index() const {return type;}
 599                 Cause& select_id_Cause() { return set<Cause>(1); }
 600                 Cause const* get_id_Cause() const { return get<Cause>(1); }
 601                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
 602                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
 603                 bool is_unknown() const { return type == 3; }
 604                 void clear()
 605                 {
 606                         switch(type)
 607                         {
 608                         case 1: var.destroy<Cause>(); break;
 609                         case 2: var.destroy<CriticalityDiagnostics>(); break;
 610                         }
 611                         type = 0; ref_nested().clear();
 612                 }
 613                 template<typename V> static inline void enumerate(V& v)
 614                 {
 615                         v.template operator()<Cause>(1);
 616                         v.template operator()<CriticalityDiagnostics>(2);
 617
 618                 }
 619                 protected:
 620                 template<typename V> bool decode(size_t index, V& v)
 621                 {
 622                         clear();
 623                         switch(index)
 624                         {
 625                         case 1: v(select_id_Cause()); return true;
 626                         case 2: v(select_id_CriticalityDiagnostics()); return true;
 627                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
 628                         }
 629                         return false;
 630
 631                 }
 632                 template<typename V> bool encode(size_t index, V& v) const
 633                 {
 634                         if(index != type) return false;
 635                         switch(type)
 636                         {
 637                         case 1: v(var.as<Cause>()); return true;
 638                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
 639                         }
 640                         return false;
 641
 642                 }
 643                 private:
 644                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
 645                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
 646                 union union_type
 647                 {
 648                         char dummy1[sizeof(Cause)];
 649                         char dummy2[sizeof(CriticalityDiagnostics)];
 650
 651                 };
 652                 asn::variant<sizeof(union_type)> var;
 653                 size_t type {0};
 654
 655         };
 656         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
 657         {
 658                 size_t get_index() const {return type;}
 659                 bool is_unknown() const { return type == 3; }
 660                 void clear() {type = 0;}
 661                 void select_id_Cause() { set(mandatory); type=1;}
 662                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
 663                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
 664                 template<typename V>  bool decode(V& v)
 665                 {
 666                         clear();
 667                         if(!v(ref_nested())) return false;
 668                         if(equal(mandatory)) { type = 1; return true; }
 669                         else if(equal(optional)) { type = 2; return true; }
 670                         else { type = 3; return true;}
 671                         return false;
 672
 673                 }
 674                 template<typename V> bool encode(V& v) const
 675                 {
 676                         return v(ref_nested());
 677
 678                 }
 679                 protected:
 680                 template<typename V>  bool decode(size_t index, V& v)
 681                 {
 682                         clear();
 683                         switch(index)
 684                         {
 685                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
 686                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
 687                         case 3: type = 3; return v(ref_nested());
 688                         ref_nested().clear();
 689                         }
 690                         return false;
 691
 692                 }
 693                 template<typename V> bool encode(size_t index, V& v) const
 694                 {
 695                         if(index != type) {return false;} return v(ref_nested());
 696
 697                 }
 698                 private:
 699                 size_t type {0};
 700
 701         };
 702
 703 };
 704 /*
 705 CellActivationFailure ::= SEQUENCE {
 706         protocolIEs             ProtocolIE-Container    {{CellActivationFailure-IEs}},
 707         ...
 708 }
 709 */
 710
 711 struct CellActivationFailure : asn::sequence<1, 0, true, 0>
 712 {
 713         static constexpr const char* name() {return "CellActivationFailure";}
 714         using parent_t = asn::sequence<1, 0, true, 0>;
 715         struct protocolIEs_t : ProtocolIE_Container<CellActivationFailure_IEs>
 716         {
 717                 static constexpr const char* name() {return "protocolIEs_t";}
 718                 using parent_t = ProtocolIE_Container<CellActivationFailure_IEs>;
 719
 720         };
 721         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
 722         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
 723         template<typename V> void decode(V& v)
 724         {
 725                 v(protocolIEs);
 726
 727         };
 728         template<typename V> void encode(V& v) const
 729         {
 730                 v(protocolIEs);
 731
 732         };
 733         void clear()
 734         {
 735                 protocolIEs.clear();
 736
 737         };
 738         private:
 739         protocolIEs_t   protocolIEs;
 740
 741 };
 742 /*
 743 ServedCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
 744         ...
 745 }
 746 */
 747
 748 struct ServedCellsToActivate_Item_ExtIEs
 749 {
 750         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
 751         {
 752                 size_t get_index() const {return type;}
 753                 bool is_unknown() const { return type == 1; }
 754                 void clear() {type = 0;}
 755                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
 756                 template<typename V>  bool decode(V& v)
 757                 {
 758                         clear();
 759                         if(!v(ref_nested())) return false;
 760                         { type = 1; return true;}
 761                         return false;
 762
 763                 }
 764                 template<typename V> bool encode(V& v) const
 765                 {
 766                         return v(ref_nested());
 767
 768                 }
 769                 protected:
 770                 template<typename V>  bool decode(size_t index, V& v)
 771                 {
 772                         clear();
 773                         switch(index)
 774                         {
 775                         case 1: type = 1; return v(ref_nested());
 776                         ref_nested().clear();
 777                         }
 778                         return false;
 779
 780                 }
 781                 template<typename V> bool encode(size_t index, V& v) const
 782                 {
 783                         if(index != type) {return false;} return v(ref_nested());
 784
 785                 }
 786                 private:
 787                 size_t type {0};
 788
 789         };
 790         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
 791         {
 792                 size_t get_index() const {return type;}
 793                 bool is_unknown() const { return type == 1; }
 794                 void clear() {type = 0;}
 795                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
 796                 template<typename V>  bool decode(V& v)
 797                 {
 798                         clear();
 799                         if(!v(ref_nested())) return false;
 800                         { type = 1; return true;}
 801                         return false;
 802
 803                 }
 804                 template<typename V> bool encode(V& v) const
 805                 {
 806                         return v(ref_nested());
 807
 808                 }
 809                 protected:
 810                 template<typename V>  bool decode(size_t index, V& v)
 811                 {
 812                         clear();
 813                         switch(index)
 814                         {
 815                         case 1: type = 1; return v(ref_nested());
 816                         ref_nested().clear();
 817                         }
 818                         return false;
 819
 820                 }
 821                 template<typename V> bool encode(size_t index, V& v) const
 822                 {
 823                         if(index != type) {return false;} return v(ref_nested());
 824
 825                 }
 826                 private:
 827                 size_t type {0};
 828
 829         };
 830         struct Extension_t : asn::typefield<true>
 831         {
 832                 ~Extension_t()  {clear();}
 833                 size_t get_index() const {return type;}
 834                 bool is_unknown() const { return type == 1; }
 835                 void clear()
 836                 {
 837                         type = 0; ref_nested().clear();
 838                 }
 839                 template<typename V> static inline void enumerate(V& v)
 840                 {
 841
 842                 }
 843                 protected:
 844                 template<typename V> bool decode(size_t index, V& v)
 845                 {
 846                         clear();
 847                         switch(index)
 848                         {
 849                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
 850                         }
 851                         return false;
 852
 853                 }
 854                 template<typename V> bool encode(size_t index, V& v) const
 855                 {
 856                         if(index != type) return false;
 857                         return false;
 858
 859                 }
 860                 private:
 861                 size_t type {0};
 862
 863         };
 864         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
 865         {
 866                 size_t get_index() const {return type;}
 867                 bool is_unknown() const { return type == 1; }
 868                 void clear() {type = 0;}
 869                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
 870                 template<typename V>  bool decode(V& v)
 871                 {
 872                         clear();
 873                         if(!v(ref_nested())) return false;
 874                         { type = 1; return true;}
 875                         return false;
 876
 877                 }
 878                 template<typename V> bool encode(V& v) const
 879                 {
 880                         return v(ref_nested());
 881
 882                 }
 883                 protected:
 884                 template<typename V>  bool decode(size_t index, V& v)
 885                 {
 886                         clear();
 887                         switch(index)
 888                         {
 889                         case 1: type = 1; return v(ref_nested());
 890                         ref_nested().clear();
 891                         }
 892                         return false;
 893
 894                 }
 895                 template<typename V> bool encode(size_t index, V& v) const
 896                 {
 897                         if(index != type) {return false;} return v(ref_nested());
 898
 899                 }
 900                 private:
 901                 size_t type {0};
 902
 903         };
 904
 905 };
 906 /*
 907 ServedCellsToActivate-Item::= SEQUENCE {
 908         ecgi                                            ECGI,
 909         iE-Extensions                                   ProtocolExtensionContainer { {ServedCellsToActivate-Item-ExtIEs} } OPTIONAL,
 910         ...
 911 }
 912 */
 913
 914 struct ServedCellsToActivate_Item : asn::sequence<2, 0, true, 1>
 915 {
 916         static constexpr const char* name() {return "ServedCellsToActivate-Item";}
 917         using parent_t = asn::sequence<2, 0, true, 1>;
 918         struct ecgi_t : ECGI
 919         {
 920                 static constexpr const char* name() {return "ecgi_t";}
 921                 using parent_t = ECGI;
 922
 923         };
 924         ecgi_t& ref_ecgi() {return ecgi;}
 925         ecgi_t const& ref_ecgi() const {return ecgi;}
 926         struct iE_Extensions_t : ProtocolExtensionContainer<ServedCellsToActivate_Item_ExtIEs>
 927         {
 928                 static constexpr const char* name() {return "iE_Extensions_t";}
 929                 using parent_t = ProtocolExtensionContainer<ServedCellsToActivate_Item_ExtIEs>;
 930                 static constexpr bool optional = true;
 931
 932         };
 933         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
 934         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
 935         template<typename V> void decode(V& v)
 936         {
 937                 v(ecgi);
 938                 v(iE_Extensions);
 939
 940         };
 941         template<typename V> void encode(V& v) const
 942         {
 943                 v(ecgi);
 944                 v(iE_Extensions);
 945
 946         };
 947         void clear()
 948         {
 949                 ecgi.clear();
 950                 iE_Extensions.clear();
 951
 952         };
 953         private:
 954         ecgi_t  ecgi;
 955         iE_Extensions_t iE_Extensions;
 956
 957 };
 958 /*
 959 ServedCellsToActivate::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToActivate-Item
 960 */
 961
 962 struct ServedCellsToActivate_elm : ServedCellsToActivate_Item
 963 {
 964         static constexpr const char* name() {return "ServedCellsToActivate_elm";}
 965         using parent_t = ServedCellsToActivate_Item;
 966
 967 };
 968 struct ServedCellsToActivate : asn::sequenceof<ServedCellsToActivate_elm>
 969 {
 970         static constexpr const char* name() {return "ServedCellsToActivate";}
 971         using parent_t = asn::sequenceof<ServedCellsToActivate_elm>;
 972         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
 973
 974 };
 975 /*
 976 CellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
 977         { ID id-ServedCellsToActivate   CRITICALITY reject      TYPE ServedCellsToActivate              PRESENCE mandatory},
 978         ...
 979 }
 980 */
 981
 982 struct CellActivationRequest_IEs
 983 {
 984         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
 985         {
 986                 size_t get_index() const {return type;}
 987                 bool is_unknown() const { return type == 2; }
 988                 void clear() {type = 0;}
 989                 void select_id_ServedCellsToActivate() { set(id_ServedCellsToActivate); type=1;}
 990                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
 991                 template<typename V>  bool decode(V& v)
 992                 {
 993                         clear();
 994                         if(!v(ref_nested())) return false;
 995                         if(equal(id_ServedCellsToActivate)) { type = 1; return true; }
 996                         else { type = 2; return true;}
 997                         return false;
 998
 999                 }
1000                 template<typename V> bool encode(V& v) const
1001                 {
1002                         return v(ref_nested());
1003
1004                 }
1005                 protected:
1006                 template<typename V>  bool decode(size_t index, V& v)
1007                 {
1008                         clear();
1009                         switch(index)
1010                         {
1011                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedCellsToActivate);} return false;
1012                         case 2: type = 2; return v(ref_nested());
1013                         ref_nested().clear();
1014                         }
1015                         return false;
1016
1017                 }
1018                 template<typename V> bool encode(size_t index, V& v) const
1019                 {
1020                         if(index != type) {return false;} return v(ref_nested());
1021
1022                 }
1023                 private:
1024                 size_t type {0};
1025
1026         };
1027         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
1028         {
1029                 size_t get_index() const {return type;}
1030                 bool is_unknown() const { return type == 2; }
1031                 void clear() {type = 0;}
1032                 void select_id_ServedCellsToActivate() { set(reject); type=1;}
1033                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
1034                 template<typename V>  bool decode(V& v)
1035                 {
1036                         clear();
1037                         if(!v(ref_nested())) return false;
1038                         if(equal(reject)) { type = 1; return true; }
1039                         else { type = 2; return true;}
1040                         return false;
1041
1042                 }
1043                 template<typename V> bool encode(V& v) const
1044                 {
1045                         return v(ref_nested());
1046
1047                 }
1048                 protected:
1049                 template<typename V>  bool decode(size_t index, V& v)
1050                 {
1051                         clear();
1052                         switch(index)
1053                         {
1054                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
1055                         case 2: type = 2; return v(ref_nested());
1056                         ref_nested().clear();
1057                         }
1058                         return false;
1059
1060                 }
1061                 template<typename V> bool encode(size_t index, V& v) const
1062                 {
1063                         if(index != type) {return false;} return v(ref_nested());
1064
1065                 }
1066                 private:
1067                 size_t type {0};
1068
1069         };
1070         struct Value_t : asn::typefield<true>
1071         {
1072                 ~Value_t()      {clear();}
1073                 size_t get_index() const {return type;}
1074                 ServedCellsToActivate& select_id_ServedCellsToActivate() { return set<ServedCellsToActivate>(1); }
1075                 ServedCellsToActivate const* get_id_ServedCellsToActivate() const { return get<ServedCellsToActivate>(1); }
1076                 bool is_unknown() const { return type == 2; }
1077                 void clear()
1078                 {
1079                         switch(type)
1080                         {
1081                         case 1: var.destroy<ServedCellsToActivate>(); break;
1082                         }
1083                         type = 0; ref_nested().clear();
1084                 }
1085                 template<typename V> static inline void enumerate(V& v)
1086                 {
1087                         v.template operator()<ServedCellsToActivate>(1);
1088
1089                 }
1090                 protected:
1091                 template<typename V> bool decode(size_t index, V& v)
1092                 {
1093                         clear();
1094                         switch(index)
1095                         {
1096                         case 1: v(select_id_ServedCellsToActivate()); return true;
1097                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
1098                         }
1099                         return false;
1100
1101                 }
1102                 template<typename V> bool encode(size_t index, V& v) const
1103                 {
1104                         if(index != type) return false;
1105                         switch(type)
1106                         {
1107                         case 1: v(var.as<ServedCellsToActivate>()); return true;
1108                         }
1109                         return false;
1110
1111                 }
1112                 private:
1113                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1114                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1115                 union union_type
1116                 {
1117                         char dummy1[sizeof(ServedCellsToActivate)];
1118
1119                 };
1120                 asn::variant<sizeof(union_type)> var;
1121                 size_t type {0};
1122
1123         };
1124         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
1125         {
1126                 size_t get_index() const {return type;}
1127                 bool is_unknown() const { return type == 2; }
1128                 void clear() {type = 0;}
1129                 void select_id_ServedCellsToActivate() { set(mandatory); type=1;}
1130                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
1131                 template<typename V>  bool decode(V& v)
1132                 {
1133                         clear();
1134                         if(!v(ref_nested())) return false;
1135                         if(equal(mandatory)) { type = 1; return true; }
1136                         else { type = 2; return true;}
1137                         return false;
1138
1139                 }
1140                 template<typename V> bool encode(V& v) const
1141                 {
1142                         return v(ref_nested());
1143
1144                 }
1145                 protected:
1146                 template<typename V>  bool decode(size_t index, V& v)
1147                 {
1148                         clear();
1149                         switch(index)
1150                         {
1151                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
1152                         case 2: type = 2; return v(ref_nested());
1153                         ref_nested().clear();
1154                         }
1155                         return false;
1156
1157                 }
1158                 template<typename V> bool encode(size_t index, V& v) const
1159                 {
1160                         if(index != type) {return false;} return v(ref_nested());
1161
1162                 }
1163                 private:
1164                 size_t type {0};
1165
1166         };
1167
1168 };
1169 /*
1170 CellActivationRequest ::= SEQUENCE {
1171         protocolIEs             ProtocolIE-Container    {{CellActivationRequest-IEs}},
1172         ...
1173 }
1174 */
1175
1176 struct CellActivationRequest : asn::sequence<1, 0, true, 0>
1177 {
1178         static constexpr const char* name() {return "CellActivationRequest";}
1179         using parent_t = asn::sequence<1, 0, true, 0>;
1180         struct protocolIEs_t : ProtocolIE_Container<CellActivationRequest_IEs>
1181         {
1182                 static constexpr const char* name() {return "protocolIEs_t";}
1183                 using parent_t = ProtocolIE_Container<CellActivationRequest_IEs>;
1184
1185         };
1186         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
1187         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
1188         template<typename V> void decode(V& v)
1189         {
1190                 v(protocolIEs);
1191
1192         };
1193         template<typename V> void encode(V& v) const
1194         {
1195                 v(protocolIEs);
1196
1197         };
1198         void clear()
1199         {
1200                 protocolIEs.clear();
1201
1202         };
1203         private:
1204         protocolIEs_t   protocolIEs;
1205
1206 };
1207 /*
1208 CellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
1209         { ID id-ActivatedCellList               CRITICALITY ignore      TYPE ActivatedCellList                          PRESENCE mandatory}|
1210         { ID id-CriticalityDiagnostics  CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional},
1211         ...
1212 }
1213 */
1214
1215 struct CellActivationResponse_IEs
1216 {
1217         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
1218         {
1219                 size_t get_index() const {return type;}
1220                 bool is_unknown() const { return type == 3; }
1221                 void clear() {type = 0;}
1222                 void select_id_ActivatedCellList() { set(id_ActivatedCellList); type=1;}
1223                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
1224                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
1225                 template<typename V>  bool decode(V& v)
1226                 {
1227                         clear();
1228                         if(!v(ref_nested())) return false;
1229                         if(equal(id_ActivatedCellList)) { type = 1; return true; }
1230                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
1231                         else { type = 3; return true;}
1232                         return false;
1233
1234                 }
1235                 template<typename V> bool encode(V& v) const
1236                 {
1237                         return v(ref_nested());
1238
1239                 }
1240                 protected:
1241                 template<typename V>  bool decode(size_t index, V& v)
1242                 {
1243                         clear();
1244                         switch(index)
1245                         {
1246                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivatedCellList);} return false;
1247                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
1248                         case 3: type = 3; return v(ref_nested());
1249                         ref_nested().clear();
1250                         }
1251                         return false;
1252
1253                 }
1254                 template<typename V> bool encode(size_t index, V& v) const
1255                 {
1256                         if(index != type) {return false;} return v(ref_nested());
1257
1258                 }
1259                 private:
1260                 size_t type {0};
1261
1262         };
1263         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
1264         {
1265                 size_t get_index() const {return type;}
1266                 bool is_unknown() const { return type == 3; }
1267                 void clear() {type = 0;}
1268                 void select_id_ActivatedCellList() { set(ignore); type=1;}
1269                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
1270                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
1271                 template<typename V>  bool decode(V& v)
1272                 {
1273                         clear();
1274                         if(!v(ref_nested())) return false;
1275                         if(equal(ignore)) { type = 1; return true; }
1276                         else if(equal(ignore)) { type = 2; return true; }
1277                         else { type = 3; return true;}
1278                         return false;
1279
1280                 }
1281                 template<typename V> bool encode(V& v) const
1282                 {
1283                         return v(ref_nested());
1284
1285                 }
1286                 protected:
1287                 template<typename V>  bool decode(size_t index, V& v)
1288                 {
1289                         clear();
1290                         switch(index)
1291                         {
1292                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
1293                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
1294                         case 3: type = 3; return v(ref_nested());
1295                         ref_nested().clear();
1296                         }
1297                         return false;
1298
1299                 }
1300                 template<typename V> bool encode(size_t index, V& v) const
1301                 {
1302                         if(index != type) {return false;} return v(ref_nested());
1303
1304                 }
1305                 private:
1306                 size_t type {0};
1307
1308         };
1309         struct Value_t : asn::typefield<true>
1310         {
1311                 ~Value_t()      {clear();}
1312                 size_t get_index() const {return type;}
1313                 ActivatedCellList& select_id_ActivatedCellList() { return set<ActivatedCellList>(1); }
1314                 ActivatedCellList const* get_id_ActivatedCellList() const { return get<ActivatedCellList>(1); }
1315                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
1316                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
1317                 bool is_unknown() const { return type == 3; }
1318                 void clear()
1319                 {
1320                         switch(type)
1321                         {
1322                         case 1: var.destroy<ActivatedCellList>(); break;
1323                         case 2: var.destroy<CriticalityDiagnostics>(); break;
1324                         }
1325                         type = 0; ref_nested().clear();
1326                 }
1327                 template<typename V> static inline void enumerate(V& v)
1328                 {
1329                         v.template operator()<ActivatedCellList>(1);
1330                         v.template operator()<CriticalityDiagnostics>(2);
1331
1332                 }
1333                 protected:
1334                 template<typename V> bool decode(size_t index, V& v)
1335                 {
1336                         clear();
1337                         switch(index)
1338                         {
1339                         case 1: v(select_id_ActivatedCellList()); return true;
1340                         case 2: v(select_id_CriticalityDiagnostics()); return true;
1341                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
1342                         }
1343                         return false;
1344
1345                 }
1346                 template<typename V> bool encode(size_t index, V& v) const
1347                 {
1348                         if(index != type) return false;
1349                         switch(type)
1350                         {
1351                         case 1: v(var.as<ActivatedCellList>()); return true;
1352                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
1353                         }
1354                         return false;
1355
1356                 }
1357                 private:
1358                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1359                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1360                 union union_type
1361                 {
1362                         char dummy1[sizeof(ActivatedCellList)];
1363                         char dummy2[sizeof(CriticalityDiagnostics)];
1364
1365                 };
1366                 asn::variant<sizeof(union_type)> var;
1367                 size_t type {0};
1368
1369         };
1370         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
1371         {
1372                 size_t get_index() const {return type;}
1373                 bool is_unknown() const { return type == 3; }
1374                 void clear() {type = 0;}
1375                 void select_id_ActivatedCellList() { set(mandatory); type=1;}
1376                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
1377                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
1378                 template<typename V>  bool decode(V& v)
1379                 {
1380                         clear();
1381                         if(!v(ref_nested())) return false;
1382                         if(equal(mandatory)) { type = 1; return true; }
1383                         else if(equal(optional)) { type = 2; return true; }
1384                         else { type = 3; return true;}
1385                         return false;
1386
1387                 }
1388                 template<typename V> bool encode(V& v) const
1389                 {
1390                         return v(ref_nested());
1391
1392                 }
1393                 protected:
1394                 template<typename V>  bool decode(size_t index, V& v)
1395                 {
1396                         clear();
1397                         switch(index)
1398                         {
1399                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
1400                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
1401                         case 3: type = 3; return v(ref_nested());
1402                         ref_nested().clear();
1403                         }
1404                         return false;
1405
1406                 }
1407                 template<typename V> bool encode(size_t index, V& v) const
1408                 {
1409                         if(index != type) {return false;} return v(ref_nested());
1410
1411                 }
1412                 private:
1413                 size_t type {0};
1414
1415         };
1416
1417 };
1418 /*
1419 CellActivationResponse ::= SEQUENCE {
1420         protocolIEs             ProtocolIE-Container    {{CellActivationResponse-IEs}},
1421         ...
1422 }
1423 */
1424
1425 struct CellActivationResponse : asn::sequence<1, 0, true, 0>
1426 {
1427         static constexpr const char* name() {return "CellActivationResponse";}
1428         using parent_t = asn::sequence<1, 0, true, 0>;
1429         struct protocolIEs_t : ProtocolIE_Container<CellActivationResponse_IEs>
1430         {
1431                 static constexpr const char* name() {return "protocolIEs_t";}
1432                 using parent_t = ProtocolIE_Container<CellActivationResponse_IEs>;
1433
1434         };
1435         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
1436         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
1437         template<typename V> void decode(V& v)
1438         {
1439                 v(protocolIEs);
1440
1441         };
1442         template<typename V> void encode(V& v) const
1443         {
1444                 v(protocolIEs);
1445
1446         };
1447         void clear()
1448         {
1449                 protocolIEs.clear();
1450
1451         };
1452         private:
1453         protocolIEs_t   protocolIEs;
1454
1455 };
1456 /*
1457 Limited-list-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1458         ...
1459 }
1460 */
1461
1462 struct Limited_list_ExtIEs
1463 {
1464         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1465         {
1466                 size_t get_index() const {return type;}
1467                 bool is_unknown() const { return type == 1; }
1468                 void clear() {type = 0;}
1469                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1470                 template<typename V>  bool decode(V& v)
1471                 {
1472                         clear();
1473                         if(!v(ref_nested())) return false;
1474                         { type = 1; return true;}
1475                         return false;
1476
1477                 }
1478                 template<typename V> bool encode(V& v) const
1479                 {
1480                         return v(ref_nested());
1481
1482                 }
1483                 protected:
1484                 template<typename V>  bool decode(size_t index, V& v)
1485                 {
1486                         clear();
1487                         switch(index)
1488                         {
1489                         case 1: type = 1; return v(ref_nested());
1490                         ref_nested().clear();
1491                         }
1492                         return false;
1493
1494                 }
1495                 template<typename V> bool encode(size_t index, V& v) const
1496                 {
1497                         if(index != type) {return false;} return v(ref_nested());
1498
1499                 }
1500                 private:
1501                 size_t type {0};
1502
1503         };
1504         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1505         {
1506                 size_t get_index() const {return type;}
1507                 bool is_unknown() const { return type == 1; }
1508                 void clear() {type = 0;}
1509                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1510                 template<typename V>  bool decode(V& v)
1511                 {
1512                         clear();
1513                         if(!v(ref_nested())) return false;
1514                         { type = 1; return true;}
1515                         return false;
1516
1517                 }
1518                 template<typename V> bool encode(V& v) const
1519                 {
1520                         return v(ref_nested());
1521
1522                 }
1523                 protected:
1524                 template<typename V>  bool decode(size_t index, V& v)
1525                 {
1526                         clear();
1527                         switch(index)
1528                         {
1529                         case 1: type = 1; return v(ref_nested());
1530                         ref_nested().clear();
1531                         }
1532                         return false;
1533
1534                 }
1535                 template<typename V> bool encode(size_t index, V& v) const
1536                 {
1537                         if(index != type) {return false;} return v(ref_nested());
1538
1539                 }
1540                 private:
1541                 size_t type {0};
1542
1543         };
1544         struct Extension_t : asn::typefield<true>
1545         {
1546                 ~Extension_t()  {clear();}
1547                 size_t get_index() const {return type;}
1548                 bool is_unknown() const { return type == 1; }
1549                 void clear()
1550                 {
1551                         type = 0; ref_nested().clear();
1552                 }
1553                 template<typename V> static inline void enumerate(V& v)
1554                 {
1555
1556                 }
1557                 protected:
1558                 template<typename V> bool decode(size_t index, V& v)
1559                 {
1560                         clear();
1561                         switch(index)
1562                         {
1563                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1564                         }
1565                         return false;
1566
1567                 }
1568                 template<typename V> bool encode(size_t index, V& v) const
1569                 {
1570                         if(index != type) return false;
1571                         return false;
1572
1573                 }
1574                 private:
1575                 size_t type {0};
1576
1577         };
1578         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1579         {
1580                 size_t get_index() const {return type;}
1581                 bool is_unknown() const { return type == 1; }
1582                 void clear() {type = 0;}
1583                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1584                 template<typename V>  bool decode(V& v)
1585                 {
1586                         clear();
1587                         if(!v(ref_nested())) return false;
1588                         { type = 1; return true;}
1589                         return false;
1590
1591                 }
1592                 template<typename V> bool encode(V& v) const
1593                 {
1594                         return v(ref_nested());
1595
1596                 }
1597                 protected:
1598                 template<typename V>  bool decode(size_t index, V& v)
1599                 {
1600                         clear();
1601                         switch(index)
1602                         {
1603                         case 1: type = 1; return v(ref_nested());
1604                         ref_nested().clear();
1605                         }
1606                         return false;
1607
1608                 }
1609                 template<typename V> bool encode(size_t index, V& v) const
1610                 {
1611                         if(index != type) {return false;} return v(ref_nested());
1612
1613                 }
1614                 private:
1615                 size_t type {0};
1616
1617         };
1618
1619 };
1620 /*
1621 Limited-list    ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF SEQUENCE {
1622         nrCellID                        NRCGI,
1623                 iE-Extensions                                           ProtocolExtensionContainer { {Limited-list-ExtIEs} } OPTIONAL,
1624         ...
1625 }
1626 */
1627
1628 struct Limited_list_elm : asn::sequence<2, 0, true, 1>
1629 {
1630         static constexpr const char* name() {return "Limited_list_elm";}
1631         using parent_t = asn::sequence<2, 0, true, 1>;
1632         struct nrCellID_t : NRCGI
1633         {
1634                 static constexpr const char* name() {return "nrCellID_t";}
1635                 using parent_t = NRCGI;
1636
1637         };
1638         nrCellID_t& ref_nrCellID() {return nrCellID;}
1639         nrCellID_t const& ref_nrCellID() const {return nrCellID;}
1640         struct iE_Extensions_t : ProtocolExtensionContainer<Limited_list_ExtIEs>
1641         {
1642                 static constexpr const char* name() {return "iE_Extensions_t";}
1643                 using parent_t = ProtocolExtensionContainer<Limited_list_ExtIEs>;
1644                 static constexpr bool optional = true;
1645
1646         };
1647         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1648         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1649         template<typename V> void decode(V& v)
1650         {
1651                 v(nrCellID);
1652                 v(iE_Extensions);
1653
1654         };
1655         template<typename V> void encode(V& v) const
1656         {
1657                 v(nrCellID);
1658                 v(iE_Extensions);
1659
1660         };
1661         void clear()
1662         {
1663                 nrCellID.clear();
1664                 iE_Extensions.clear();
1665
1666         };
1667         private:
1668         nrCellID_t      nrCellID;
1669         iE_Extensions_t iE_Extensions;
1670
1671 };
1672 struct Limited_list : asn::sequenceof<Limited_list_elm>
1673 {
1674         static constexpr const char* name() {return "Limited-list";}
1675         using parent_t = asn::sequenceof<Limited_list_elm>;
1676         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
1677
1678 };
1679 /*
1680 CellAssistanceInformation ::= CHOICE {
1681         limited-list                            Limited-list,
1682         full-list                               ENUMERATED {allServedNRcells, ...},
1683         ...
1684 }
1685 */
1686
1687 struct CellAssistanceInformation : asn::choice<2, 0, true>
1688 {
1689         static constexpr const char* name() {return "CellAssistanceInformation";}
1690         using parent_t = asn::choice<2, 0, true>;
1691         index_type get_index() const {return index;}
1692         bool is_unknown() const {return index == 3;}
1693         void set_unknown() { set_index(3);  }
1694         ~CellAssistanceInformation() {clear();}
1695         struct limited_list_t : Limited_list
1696         {
1697                 static constexpr const char* name() {return "limited_list_t";}
1698                 using parent_t = Limited_list;
1699
1700         };
1701         struct full_list_t : asn::enumerated<1, 0, true>
1702         {
1703                 static constexpr const char* name() {return "full_list_t";}
1704                 using parent_t = asn::enumerated<1, 0, true>;
1705                 typedef enum {
1706                         allServedNRcells
1707                 } index_t;
1708
1709         };
1710
1711         void clear()
1712         {
1713                 switch(get_index())
1714                 {
1715                 case 1: var.destroy<limited_list_t>(); break;
1716                 case 2: var.destroy<full_list_t>(); break;
1717                 }
1718                 index = 0;
1719                 base::clear();
1720         }
1721         template<typename V> bool decode(size_t idx, V& v)
1722         {
1723                 clear();
1724                 switch(idx)
1725                 {
1726                 case 1: set_index(1); return v(var.build<limited_list_t>());
1727                 case 2: set_index(2); return v(var.build<full_list_t>());
1728                 }
1729                 return false;
1730
1731         }
1732         template<typename V> bool encode(V& v) const
1733         {
1734                 switch(get_index())
1735                 {
1736                 case 1: return v(var.as<limited_list_t>());
1737                 case 2: return v(var.as<full_list_t>());
1738                 }
1739                 return false;
1740         }
1741         template<typename V> static inline void enumerate(V& v)
1742         {
1743                 v.template operator()<limited_list_t>(1);
1744                 v.template operator()<full_list_t>(2);
1745
1746         }
1747         limited_list_t& select_limited_list() { if(get_index() != 1) { clear(); set_index(1); return var.build<limited_list_t>();} return var.as<limited_list_t>();}
1748         limited_list_t const* get_limited_list() const { if(get_index() == 1) { return &var.as<limited_list_t>();} return nullptr; }
1749         full_list_t& select_full_list() { if(get_index() != 2) { clear(); set_index(2); return var.build<full_list_t>();} return var.as<full_list_t>();}
1750         full_list_t const* get_full_list() const { if(get_index() == 2) { return &var.as<full_list_t>();} return nullptr; }
1751         private:
1752         void set_index(index_type i) {index = i; base::set();}
1753         union union_type
1754         {
1755                 char dummy1[sizeof(limited_list_t)];
1756                 char dummy2[sizeof(full_list_t)];
1757
1758         };
1759         asn::variant<sizeof(union_type)>        var;
1760         index_type      index {0};
1761 };
1762 /*
1763 CellInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1764 { ID id-ABSInformation                                          CRITICALITY ignore      EXTENSION ABSInformation                                                        PRESENCE optional }|
1765 { ID id-InvokeIndication                                        CRITICALITY ignore      EXTENSION InvokeIndication                                                      PRESENCE optional }|
1766 { ID id-IntendedULDLConfiguration                       CRITICALITY ignore      EXTENSION SubframeAssignment                                            PRESENCE optional }|
1767 { ID id-ExtendedULInterferenceOverloadInfo      CRITICALITY ignore      EXTENSION ExtendedULInterferenceOverloadInfo    PRESENCE optional }|
1768 { ID id-CoMPInformation                                         CRITICALITY ignore      EXTENSION CoMPInformation                                                       PRESENCE optional }|
1769 { ID id-DynamicDLTransmissionInformation        CRITICALITY ignore      EXTENSION DynamicDLTransmissionInformation              PRESENCE optional },
1770         ...
1771 }
1772 */
1773
1774 struct CellInformation_Item_ExtIEs
1775 {
1776         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1777         {
1778                 size_t get_index() const {return type;}
1779                 bool is_unknown() const { return type == 7; }
1780                 void clear() {type = 0;}
1781                 void select_id_ABSInformation() { set(id_ABSInformation); type=1;}
1782                 void select_id_InvokeIndication() { set(id_InvokeIndication); type=2;}
1783                 void select_id_IntendedULDLConfiguration() { set(id_IntendedULDLConfiguration); type=3;}
1784                 void select_id_ExtendedULInterferenceOverloadInfo() { set(id_ExtendedULInterferenceOverloadInfo); type=4;}
1785                 void select_id_CoMPInformation() { set(id_CoMPInformation); type=5;}
1786                 void select_id_DynamicDLTransmissionInformation() { set(id_DynamicDLTransmissionInformation); type=6;}
1787                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1788                 template<typename V>  bool decode(V& v)
1789                 {
1790                         clear();
1791                         if(!v(ref_nested())) return false;
1792                         if(equal(id_ABSInformation)) { type = 1; return true; }
1793                         else if(equal(id_InvokeIndication)) { type = 2; return true; }
1794                         else if(equal(id_IntendedULDLConfiguration)) { type = 3; return true; }
1795                         else if(equal(id_ExtendedULInterferenceOverloadInfo)) { type = 4; return true; }
1796                         else if(equal(id_CoMPInformation)) { type = 5; return true; }
1797                         else if(equal(id_DynamicDLTransmissionInformation)) { type = 6; return true; }
1798                         else { type = 7; return true;}
1799                         return false;
1800
1801                 }
1802                 template<typename V> bool encode(V& v) const
1803                 {
1804                         return v(ref_nested());
1805
1806                 }
1807                 protected:
1808                 template<typename V>  bool decode(size_t index, V& v)
1809                 {
1810                         clear();
1811                         switch(index)
1812                         {
1813                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ABSInformation);} return false;
1814                         case 2: type = 2; if(v(ref_nested())) { return equal(id_InvokeIndication);} return false;
1815                         case 3: type = 3; if(v(ref_nested())) { return equal(id_IntendedULDLConfiguration);} return false;
1816                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ExtendedULInterferenceOverloadInfo);} return false;
1817                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CoMPInformation);} return false;
1818                         case 6: type = 6; if(v(ref_nested())) { return equal(id_DynamicDLTransmissionInformation);} return false;
1819                         case 7: type = 7; return v(ref_nested());
1820                         ref_nested().clear();
1821                         }
1822                         return false;
1823
1824                 }
1825                 template<typename V> bool encode(size_t index, V& v) const
1826                 {
1827                         if(index != type) {return false;} return v(ref_nested());
1828
1829                 }
1830                 private:
1831                 size_t type {0};
1832
1833         };
1834         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1835         {
1836                 size_t get_index() const {return type;}
1837                 bool is_unknown() const { return type == 7; }
1838                 void clear() {type = 0;}
1839                 void select_id_ABSInformation() { set(ignore); type=1;}
1840                 void select_id_InvokeIndication() { set(ignore); type=2;}
1841                 void select_id_IntendedULDLConfiguration() { set(ignore); type=3;}
1842                 void select_id_ExtendedULInterferenceOverloadInfo() { set(ignore); type=4;}
1843                 void select_id_CoMPInformation() { set(ignore); type=5;}
1844                 void select_id_DynamicDLTransmissionInformation() { set(ignore); type=6;}
1845                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1846                 template<typename V>  bool decode(V& v)
1847                 {
1848                         clear();
1849                         if(!v(ref_nested())) return false;
1850                         if(equal(ignore)) { type = 1; return true; }
1851                         else if(equal(ignore)) { type = 2; return true; }
1852                         else if(equal(ignore)) { type = 3; return true; }
1853                         else if(equal(ignore)) { type = 4; return true; }
1854                         else if(equal(ignore)) { type = 5; return true; }
1855                         else if(equal(ignore)) { type = 6; return true; }
1856                         else { type = 7; return true;}
1857                         return false;
1858
1859                 }
1860                 template<typename V> bool encode(V& v) const
1861                 {
1862                         return v(ref_nested());
1863
1864                 }
1865                 protected:
1866                 template<typename V>  bool decode(size_t index, V& v)
1867                 {
1868                         clear();
1869                         switch(index)
1870                         {
1871                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
1872                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
1873                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
1874                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
1875                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
1876                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
1877                         case 7: type = 7; return v(ref_nested());
1878                         ref_nested().clear();
1879                         }
1880                         return false;
1881
1882                 }
1883                 template<typename V> bool encode(size_t index, V& v) const
1884                 {
1885                         if(index != type) {return false;} return v(ref_nested());
1886
1887                 }
1888                 private:
1889                 size_t type {0};
1890
1891         };
1892         struct Extension_t : asn::typefield<true>
1893         {
1894                 ~Extension_t()  {clear();}
1895                 size_t get_index() const {return type;}
1896                 ABSInformation& select_id_ABSInformation() { return set<ABSInformation>(1); }
1897                 ABSInformation const* get_id_ABSInformation() const { return get<ABSInformation>(1); }
1898                 InvokeIndication& select_id_InvokeIndication() { return set<InvokeIndication>(2); }
1899                 InvokeIndication const* get_id_InvokeIndication() const { return get<InvokeIndication>(2); }
1900                 SubframeAssignment& select_id_IntendedULDLConfiguration() { return set<SubframeAssignment>(3); }
1901                 SubframeAssignment const* get_id_IntendedULDLConfiguration() const { return get<SubframeAssignment>(3); }
1902                 ExtendedULInterferenceOverloadInfo& select_id_ExtendedULInterferenceOverloadInfo() { return set<ExtendedULInterferenceOverloadInfo>(4); }
1903                 ExtendedULInterferenceOverloadInfo const* get_id_ExtendedULInterferenceOverloadInfo() const { return get<ExtendedULInterferenceOverloadInfo>(4); }
1904                 CoMPInformation& select_id_CoMPInformation() { return set<CoMPInformation>(5); }
1905                 CoMPInformation const* get_id_CoMPInformation() const { return get<CoMPInformation>(5); }
1906                 DynamicDLTransmissionInformation& select_id_DynamicDLTransmissionInformation() { return set<DynamicDLTransmissionInformation>(6); }
1907                 DynamicDLTransmissionInformation const* get_id_DynamicDLTransmissionInformation() const { return get<DynamicDLTransmissionInformation>(6); }
1908                 bool is_unknown() const { return type == 7; }
1909                 void clear()
1910                 {
1911                         switch(type)
1912                         {
1913                         case 1: var.destroy<ABSInformation>(); break;
1914                         case 2: var.destroy<InvokeIndication>(); break;
1915                         case 3: var.destroy<SubframeAssignment>(); break;
1916                         case 4: var.destroy<ExtendedULInterferenceOverloadInfo>(); break;
1917                         case 5: var.destroy<CoMPInformation>(); break;
1918                         case 6: var.destroy<DynamicDLTransmissionInformation>(); break;
1919                         }
1920                         type = 0; ref_nested().clear();
1921                 }
1922                 template<typename V> static inline void enumerate(V& v)
1923                 {
1924                         v.template operator()<ABSInformation>(1);
1925                         v.template operator()<InvokeIndication>(2);
1926                         v.template operator()<SubframeAssignment>(3);
1927                         v.template operator()<ExtendedULInterferenceOverloadInfo>(4);
1928                         v.template operator()<CoMPInformation>(5);
1929                         v.template operator()<DynamicDLTransmissionInformation>(6);
1930
1931                 }
1932                 protected:
1933                 template<typename V> bool decode(size_t index, V& v)
1934                 {
1935                         clear();
1936                         switch(index)
1937                         {
1938                         case 1: v(select_id_ABSInformation()); return true;
1939                         case 2: v(select_id_InvokeIndication()); return true;
1940                         case 3: v(select_id_IntendedULDLConfiguration()); return true;
1941                         case 4: v(select_id_ExtendedULInterferenceOverloadInfo()); return true;
1942                         case 5: v(select_id_CoMPInformation()); return true;
1943                         case 6: v(select_id_DynamicDLTransmissionInformation()); return true;
1944                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
1945                         }
1946                         return false;
1947
1948                 }
1949                 template<typename V> bool encode(size_t index, V& v) const
1950                 {
1951                         if(index != type) return false;
1952                         switch(type)
1953                         {
1954                         case 1: v(var.as<ABSInformation>()); return true;
1955                         case 2: v(var.as<InvokeIndication>()); return true;
1956                         case 3: v(var.as<SubframeAssignment>()); return true;
1957                         case 4: v(var.as<ExtendedULInterferenceOverloadInfo>()); return true;
1958                         case 5: v(var.as<CoMPInformation>()); return true;
1959                         case 6: v(var.as<DynamicDLTransmissionInformation>()); return true;
1960                         }
1961                         return false;
1962
1963                 }
1964                 private:
1965                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
1966                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
1967                 union union_type
1968                 {
1969                         char dummy1[sizeof(ABSInformation)];
1970                         char dummy2[sizeof(CoMPInformation)];
1971                         char dummy3[sizeof(DynamicDLTransmissionInformation)];
1972                         char dummy4[sizeof(ExtendedULInterferenceOverloadInfo)];
1973                         char dummy5[sizeof(InvokeIndication)];
1974                         char dummy6[sizeof(SubframeAssignment)];
1975
1976                 };
1977                 asn::variant<sizeof(union_type)> var;
1978                 size_t type {0};
1979
1980         };
1981         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1982         {
1983                 size_t get_index() const {return type;}
1984                 bool is_unknown() const { return type == 7; }
1985                 void clear() {type = 0;}
1986                 void select_id_ABSInformation() { set(optional); type=1;}
1987                 void select_id_InvokeIndication() { set(optional); type=2;}
1988                 void select_id_IntendedULDLConfiguration() { set(optional); type=3;}
1989                 void select_id_ExtendedULInterferenceOverloadInfo() { set(optional); type=4;}
1990                 void select_id_CoMPInformation() { set(optional); type=5;}
1991                 void select_id_DynamicDLTransmissionInformation() { set(optional); type=6;}
1992                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1993                 template<typename V>  bool decode(V& v)
1994                 {
1995                         clear();
1996                         if(!v(ref_nested())) return false;
1997                         if(equal(optional)) { type = 1; return true; }
1998                         else if(equal(optional)) { type = 2; return true; }
1999                         else if(equal(optional)) { type = 3; return true; }
2000                         else if(equal(optional)) { type = 4; return true; }
2001                         else if(equal(optional)) { type = 5; return true; }
2002                         else if(equal(optional)) { type = 6; return true; }
2003                         else { type = 7; return true;}
2004                         return false;
2005
2006                 }
2007                 template<typename V> bool encode(V& v) const
2008                 {
2009                         return v(ref_nested());
2010
2011                 }
2012                 protected:
2013                 template<typename V>  bool decode(size_t index, V& v)
2014                 {
2015                         clear();
2016                         switch(index)
2017                         {
2018                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
2019                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
2020                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
2021                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
2022                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
2023                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
2024                         case 7: type = 7; return v(ref_nested());
2025                         ref_nested().clear();
2026                         }
2027                         return false;
2028
2029                 }
2030                 template<typename V> bool encode(size_t index, V& v) const
2031                 {
2032                         if(index != type) {return false;} return v(ref_nested());
2033
2034                 }
2035                 private:
2036                 size_t type {0};
2037
2038         };
2039
2040 };
2041 /*
2042 CellInformation-Item ::= SEQUENCE {
2043         cell-ID                                                 ECGI,
2044         ul-InterferenceOverloadIndication               UL-InterferenceOverloadIndication               OPTIONAL,
2045         ul-HighInterferenceIndicationInfo               UL-HighInterferenceIndicationInfo               OPTIONAL,
2046         relativeNarrowbandTxPower                               RelativeNarrowbandTxPower                               OPTIONAL,
2047         iE-Extensions                                                   ProtocolExtensionContainer { {CellInformation-Item-ExtIEs} }    OPTIONAL,
2048         ...
2049 }
2050 */
2051
2052 struct CellInformation_Item : asn::sequence<5, 0, true, 4>
2053 {
2054         static constexpr const char* name() {return "CellInformation-Item";}
2055         using parent_t = asn::sequence<5, 0, true, 4>;
2056         struct cell_ID_t : ECGI
2057         {
2058                 static constexpr const char* name() {return "cell_ID_t";}
2059                 using parent_t = ECGI;
2060
2061         };
2062         cell_ID_t& ref_cell_ID() {return cell_ID;}
2063         cell_ID_t const& ref_cell_ID() const {return cell_ID;}
2064         struct ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
2065         {
2066                 static constexpr const char* name() {return "ul_InterferenceOverloadIndication_t";}
2067                 using parent_t = UL_InterferenceOverloadIndication;
2068                 static constexpr bool optional = true;
2069
2070         };
2071         ul_InterferenceOverloadIndication_t& set_ul_InterferenceOverloadIndication() { ul_InterferenceOverloadIndication.setpresent(true); return ul_InterferenceOverloadIndication;}
2072         ul_InterferenceOverloadIndication_t const* get_ul_InterferenceOverloadIndication() const {return ul_InterferenceOverloadIndication.is_valid() ? &ul_InterferenceOverloadIndication : nullptr;}
2073         struct ul_HighInterferenceIndicationInfo_t : UL_HighInterferenceIndicationInfo
2074         {
2075                 static constexpr const char* name() {return "ul_HighInterferenceIndicationInfo_t";}
2076                 using parent_t = UL_HighInterferenceIndicationInfo;
2077                 static constexpr bool optional = true;
2078
2079         };
2080         ul_HighInterferenceIndicationInfo_t& set_ul_HighInterferenceIndicationInfo() { ul_HighInterferenceIndicationInfo.setpresent(true); return ul_HighInterferenceIndicationInfo;}
2081         ul_HighInterferenceIndicationInfo_t const* get_ul_HighInterferenceIndicationInfo() const {return ul_HighInterferenceIndicationInfo.is_valid() ? &ul_HighInterferenceIndicationInfo : nullptr;}
2082         struct relativeNarrowbandTxPower_t : RelativeNarrowbandTxPower
2083         {
2084                 static constexpr const char* name() {return "relativeNarrowbandTxPower_t";}
2085                 using parent_t = RelativeNarrowbandTxPower;
2086                 static constexpr bool optional = true;
2087
2088         };
2089         relativeNarrowbandTxPower_t& set_relativeNarrowbandTxPower() { relativeNarrowbandTxPower.setpresent(true); return relativeNarrowbandTxPower;}
2090         relativeNarrowbandTxPower_t const* get_relativeNarrowbandTxPower() const {return relativeNarrowbandTxPower.is_valid() ? &relativeNarrowbandTxPower : nullptr;}
2091         struct iE_Extensions_t : ProtocolExtensionContainer<CellInformation_Item_ExtIEs>
2092         {
2093                 static constexpr const char* name() {return "iE_Extensions_t";}
2094                 using parent_t = ProtocolExtensionContainer<CellInformation_Item_ExtIEs>;
2095                 static constexpr bool optional = true;
2096
2097         };
2098         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2099         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2100         template<typename V> void decode(V& v)
2101         {
2102                 v(cell_ID);
2103                 v(ul_InterferenceOverloadIndication);
2104                 v(ul_HighInterferenceIndicationInfo);
2105                 v(relativeNarrowbandTxPower);
2106                 v(iE_Extensions);
2107
2108         };
2109         template<typename V> void encode(V& v) const
2110         {
2111                 v(cell_ID);
2112                 v(ul_InterferenceOverloadIndication);
2113                 v(ul_HighInterferenceIndicationInfo);
2114                 v(relativeNarrowbandTxPower);
2115                 v(iE_Extensions);
2116
2117         };
2118         void clear()
2119         {
2120                 cell_ID.clear();
2121                 ul_InterferenceOverloadIndication.clear();
2122                 ul_HighInterferenceIndicationInfo.clear();
2123                 relativeNarrowbandTxPower.clear();
2124                 iE_Extensions.clear();
2125
2126         };
2127         private:
2128         cell_ID_t       cell_ID;
2129         ul_InterferenceOverloadIndication_t     ul_InterferenceOverloadIndication;
2130         ul_HighInterferenceIndicationInfo_t     ul_HighInterferenceIndicationInfo;
2131         relativeNarrowbandTxPower_t     relativeNarrowbandTxPower;
2132         iE_Extensions_t iE_Extensions;
2133
2134 };
2135 /*
2136 CellInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
2137         { ID id-CellInformation-Item    CRITICALITY ignore      TYPE CellInformation-Item       PRESENCE mandatory      }
2138 }
2139 */
2140
2141 struct CellInformation_ItemIEs
2142 {
2143         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
2144         {
2145                 size_t get_index() const {return type;}
2146                 void clear() {type = 0;}
2147                 void select_id_CellInformation_Item() { set(id_CellInformation_Item); type=1;}
2148                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
2149                 template<typename V>  bool decode(V& v)
2150                 {
2151                         clear();
2152                         if(!v(ref_nested())) return false;
2153                         if(equal(id_CellInformation_Item)) { type = 1; return true; }
2154                         return false;
2155
2156                 }
2157                 template<typename V> bool encode(V& v) const
2158                 {
2159                         return v(ref_nested());
2160
2161                 }
2162                 protected:
2163                 template<typename V>  bool decode(size_t index, V& v)
2164                 {
2165                         clear();
2166                         switch(index)
2167                         {
2168                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CellInformation_Item);} return false;
2169                         ref_nested().clear();
2170                         }
2171                         return false;
2172
2173                 }
2174                 template<typename V> bool encode(size_t index, V& v) const
2175                 {
2176                         if(index != type) {return false;} return v(ref_nested());
2177
2178                 }
2179                 private:
2180                 size_t type {0};
2181
2182         };
2183         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
2184         {
2185                 size_t get_index() const {return type;}
2186                 void clear() {type = 0;}
2187                 void select_id_CellInformation_Item() { set(ignore); type=1;}
2188                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
2189                 template<typename V>  bool decode(V& v)
2190                 {
2191                         clear();
2192                         if(!v(ref_nested())) return false;
2193                         if(equal(ignore)) { type = 1; return true; }
2194                         return false;
2195
2196                 }
2197                 template<typename V> bool encode(V& v) const
2198                 {
2199                         return v(ref_nested());
2200
2201                 }
2202                 protected:
2203                 template<typename V>  bool decode(size_t index, V& v)
2204                 {
2205                         clear();
2206                         switch(index)
2207                         {
2208                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2209                         ref_nested().clear();
2210                         }
2211                         return false;
2212
2213                 }
2214                 template<typename V> bool encode(size_t index, V& v) const
2215                 {
2216                         if(index != type) {return false;} return v(ref_nested());
2217
2218                 }
2219                 private:
2220                 size_t type {0};
2221
2222         };
2223         struct Value_t : asn::typefield<false>
2224         {
2225                 ~Value_t()      {clear();}
2226                 size_t get_index() const {return type;}
2227                 CellInformation_Item& select_id_CellInformation_Item() { return set<CellInformation_Item>(1); }
2228                 CellInformation_Item const* get_id_CellInformation_Item() const { return get<CellInformation_Item>(1); }
2229                 void clear()
2230                 {
2231                         switch(type)
2232                         {
2233                         case 1: var.destroy<CellInformation_Item>(); break;
2234                         }
2235                         type = 0; ref_nested().clear();
2236                 }
2237                 template<typename V> static inline void enumerate(V& v)
2238                 {
2239                         v.template operator()<CellInformation_Item>(1);
2240
2241                 }
2242                 protected:
2243                 template<typename V> bool decode(size_t index, V& v)
2244                 {
2245                         clear();
2246                         switch(index)
2247                         {
2248                         case 1: v(select_id_CellInformation_Item()); return true;
2249                         }
2250                         return false;
2251
2252                 }
2253                 template<typename V> bool encode(size_t index, V& v) const
2254                 {
2255                         if(index != type) return false;
2256                         switch(type)
2257                         {
2258                         case 1: v(var.as<CellInformation_Item>()); return true;
2259                         }
2260                         return false;
2261
2262                 }
2263                 private:
2264                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2265                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2266                 union union_type
2267                 {
2268                         char dummy1[sizeof(CellInformation_Item)];
2269
2270                 };
2271                 asn::variant<sizeof(union_type)> var;
2272                 size_t type {0};
2273
2274         };
2275         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
2276         {
2277                 size_t get_index() const {return type;}
2278                 void clear() {type = 0;}
2279                 void select_id_CellInformation_Item() { set(mandatory); type=1;}
2280                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
2281                 template<typename V>  bool decode(V& v)
2282                 {
2283                         clear();
2284                         if(!v(ref_nested())) return false;
2285                         if(equal(mandatory)) { type = 1; return true; }
2286                         return false;
2287
2288                 }
2289                 template<typename V> bool encode(V& v) const
2290                 {
2291                         return v(ref_nested());
2292
2293                 }
2294                 protected:
2295                 template<typename V>  bool decode(size_t index, V& v)
2296                 {
2297                         clear();
2298                         switch(index)
2299                         {
2300                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
2301                         ref_nested().clear();
2302                         }
2303                         return false;
2304
2305                 }
2306                 template<typename V> bool encode(size_t index, V& v) const
2307                 {
2308                         if(index != type) {return false;} return v(ref_nested());
2309
2310                 }
2311                 private:
2312                 size_t type {0};
2313
2314         };
2315
2316 };
2317 /*
2318 CellInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellInformation-ItemIEs} }
2319 */
2320
2321 struct CellInformation_List_elm : ProtocolIE_Single_Container<CellInformation_ItemIEs>
2322 {
2323         static constexpr const char* name() {return "CellInformation_List_elm";}
2324         using parent_t = ProtocolIE_Single_Container<CellInformation_ItemIEs>;
2325
2326 };
2327 struct CellInformation_List : asn::sequenceof<CellInformation_List_elm>
2328 {
2329         static constexpr const char* name() {return "CellInformation-List";}
2330         using parent_t = asn::sequenceof<CellInformation_List_elm>;
2331         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
2332
2333 };
2334 /*
2335 CellMeasurementResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2336         { ID id-CompositeAvailableCapacityGroup CRITICALITY ignore      EXTENSION CompositeAvailableCapacityGroup               PRESENCE optional}|
2337         { ID id-ABS-Status                                              CRITICALITY ignore      EXTENSION ABS-Status                                                            PRESENCE optional}|
2338         { ID id-RSRPMRList                                              CRITICALITY ignore      EXTENSION RSRPMRList                                                            PRESENCE optional}|
2339         { ID id-CSIReportList                                   CRITICALITY ignore      EXTENSION CSIReportList                                                         PRESENCE optional}|
2340         { ID id-CellReportingIndicator                  CRITICALITY ignore      EXTENSION CellReportingIndicator                                        PRESENCE optional},
2341         ...
2342 }
2343 */
2344
2345 struct CellMeasurementResult_Item_ExtIEs
2346 {
2347         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2348         {
2349                 size_t get_index() const {return type;}
2350                 bool is_unknown() const { return type == 6; }
2351                 void clear() {type = 0;}
2352                 void select_id_CompositeAvailableCapacityGroup() { set(id_CompositeAvailableCapacityGroup); type=1;}
2353                 void select_id_ABS_Status() { set(id_ABS_Status); type=2;}
2354                 void select_id_RSRPMRList() { set(id_RSRPMRList); type=3;}
2355                 void select_id_CSIReportList() { set(id_CSIReportList); type=4;}
2356                 void select_id_CellReportingIndicator() { set(id_CellReportingIndicator); type=5;}
2357                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2358                 template<typename V>  bool decode(V& v)
2359                 {
2360                         clear();
2361                         if(!v(ref_nested())) return false;
2362                         if(equal(id_CompositeAvailableCapacityGroup)) { type = 1; return true; }
2363                         else if(equal(id_ABS_Status)) { type = 2; return true; }
2364                         else if(equal(id_RSRPMRList)) { type = 3; return true; }
2365                         else if(equal(id_CSIReportList)) { type = 4; return true; }
2366                         else if(equal(id_CellReportingIndicator)) { type = 5; return true; }
2367                         else { type = 6; return true;}
2368                         return false;
2369
2370                 }
2371                 template<typename V> bool encode(V& v) const
2372                 {
2373                         return v(ref_nested());
2374
2375                 }
2376                 protected:
2377                 template<typename V>  bool decode(size_t index, V& v)
2378                 {
2379                         clear();
2380                         switch(index)
2381                         {
2382                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CompositeAvailableCapacityGroup);} return false;
2383                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ABS_Status);} return false;
2384                         case 3: type = 3; if(v(ref_nested())) { return equal(id_RSRPMRList);} return false;
2385                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CSIReportList);} return false;
2386                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CellReportingIndicator);} return false;
2387                         case 6: type = 6; return v(ref_nested());
2388                         ref_nested().clear();
2389                         }
2390                         return false;
2391
2392                 }
2393                 template<typename V> bool encode(size_t index, V& v) const
2394                 {
2395                         if(index != type) {return false;} return v(ref_nested());
2396
2397                 }
2398                 private:
2399                 size_t type {0};
2400
2401         };
2402         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2403         {
2404                 size_t get_index() const {return type;}
2405                 bool is_unknown() const { return type == 6; }
2406                 void clear() {type = 0;}
2407                 void select_id_CompositeAvailableCapacityGroup() { set(ignore); type=1;}
2408                 void select_id_ABS_Status() { set(ignore); type=2;}
2409                 void select_id_RSRPMRList() { set(ignore); type=3;}
2410                 void select_id_CSIReportList() { set(ignore); type=4;}
2411                 void select_id_CellReportingIndicator() { set(ignore); type=5;}
2412                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2413                 template<typename V>  bool decode(V& v)
2414                 {
2415                         clear();
2416                         if(!v(ref_nested())) return false;
2417                         if(equal(ignore)) { type = 1; return true; }
2418                         else if(equal(ignore)) { type = 2; return true; }
2419                         else if(equal(ignore)) { type = 3; return true; }
2420                         else if(equal(ignore)) { type = 4; return true; }
2421                         else if(equal(ignore)) { type = 5; return true; }
2422                         else { type = 6; return true;}
2423                         return false;
2424
2425                 }
2426                 template<typename V> bool encode(V& v) const
2427                 {
2428                         return v(ref_nested());
2429
2430                 }
2431                 protected:
2432                 template<typename V>  bool decode(size_t index, V& v)
2433                 {
2434                         clear();
2435                         switch(index)
2436                         {
2437                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2438                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
2439                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
2440                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
2441                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
2442                         case 6: type = 6; return v(ref_nested());
2443                         ref_nested().clear();
2444                         }
2445                         return false;
2446
2447                 }
2448                 template<typename V> bool encode(size_t index, V& v) const
2449                 {
2450                         if(index != type) {return false;} return v(ref_nested());
2451
2452                 }
2453                 private:
2454                 size_t type {0};
2455
2456         };
2457         struct Extension_t : asn::typefield<true>
2458         {
2459                 ~Extension_t()  {clear();}
2460                 size_t get_index() const {return type;}
2461                 CompositeAvailableCapacityGroup& select_id_CompositeAvailableCapacityGroup() { return set<CompositeAvailableCapacityGroup>(1); }
2462                 CompositeAvailableCapacityGroup const* get_id_CompositeAvailableCapacityGroup() const { return get<CompositeAvailableCapacityGroup>(1); }
2463                 ABS_Status& select_id_ABS_Status() { return set<ABS_Status>(2); }
2464                 ABS_Status const* get_id_ABS_Status() const { return get<ABS_Status>(2); }
2465                 RSRPMRList& select_id_RSRPMRList() { return set<RSRPMRList>(3); }
2466                 RSRPMRList const* get_id_RSRPMRList() const { return get<RSRPMRList>(3); }
2467                 CSIReportList& select_id_CSIReportList() { return set<CSIReportList>(4); }
2468                 CSIReportList const* get_id_CSIReportList() const { return get<CSIReportList>(4); }
2469                 CellReportingIndicator& select_id_CellReportingIndicator() { return set<CellReportingIndicator>(5); }
2470                 CellReportingIndicator const* get_id_CellReportingIndicator() const { return get<CellReportingIndicator>(5); }
2471                 bool is_unknown() const { return type == 6; }
2472                 void clear()
2473                 {
2474                         switch(type)
2475                         {
2476                         case 1: var.destroy<CompositeAvailableCapacityGroup>(); break;
2477                         case 2: var.destroy<ABS_Status>(); break;
2478                         case 3: var.destroy<RSRPMRList>(); break;
2479                         case 4: var.destroy<CSIReportList>(); break;
2480                         case 5: var.destroy<CellReportingIndicator>(); break;
2481                         }
2482                         type = 0; ref_nested().clear();
2483                 }
2484                 template<typename V> static inline void enumerate(V& v)
2485                 {
2486                         v.template operator()<CompositeAvailableCapacityGroup>(1);
2487                         v.template operator()<ABS_Status>(2);
2488                         v.template operator()<RSRPMRList>(3);
2489                         v.template operator()<CSIReportList>(4);
2490                         v.template operator()<CellReportingIndicator>(5);
2491
2492                 }
2493                 protected:
2494                 template<typename V> bool decode(size_t index, V& v)
2495                 {
2496                         clear();
2497                         switch(index)
2498                         {
2499                         case 1: v(select_id_CompositeAvailableCapacityGroup()); return true;
2500                         case 2: v(select_id_ABS_Status()); return true;
2501                         case 3: v(select_id_RSRPMRList()); return true;
2502                         case 4: v(select_id_CSIReportList()); return true;
2503                         case 5: v(select_id_CellReportingIndicator()); return true;
2504                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
2505                         }
2506                         return false;
2507
2508                 }
2509                 template<typename V> bool encode(size_t index, V& v) const
2510                 {
2511                         if(index != type) return false;
2512                         switch(type)
2513                         {
2514                         case 1: v(var.as<CompositeAvailableCapacityGroup>()); return true;
2515                         case 2: v(var.as<ABS_Status>()); return true;
2516                         case 3: v(var.as<RSRPMRList>()); return true;
2517                         case 4: v(var.as<CSIReportList>()); return true;
2518                         case 5: v(var.as<CellReportingIndicator>()); return true;
2519                         }
2520                         return false;
2521
2522                 }
2523                 private:
2524                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2525                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2526                 union union_type
2527                 {
2528                         char dummy1[sizeof(ABS_Status)];
2529                         char dummy2[sizeof(CSIReportList)];
2530                         char dummy3[sizeof(CellReportingIndicator)];
2531                         char dummy4[sizeof(CompositeAvailableCapacityGroup)];
2532                         char dummy5[sizeof(RSRPMRList)];
2533
2534                 };
2535                 asn::variant<sizeof(union_type)> var;
2536                 size_t type {0};
2537
2538         };
2539         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2540         {
2541                 size_t get_index() const {return type;}
2542                 bool is_unknown() const { return type == 6; }
2543                 void clear() {type = 0;}
2544                 void select_id_CompositeAvailableCapacityGroup() { set(optional); type=1;}
2545                 void select_id_ABS_Status() { set(optional); type=2;}
2546                 void select_id_RSRPMRList() { set(optional); type=3;}
2547                 void select_id_CSIReportList() { set(optional); type=4;}
2548                 void select_id_CellReportingIndicator() { set(optional); type=5;}
2549                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2550                 template<typename V>  bool decode(V& v)
2551                 {
2552                         clear();
2553                         if(!v(ref_nested())) return false;
2554                         if(equal(optional)) { type = 1; return true; }
2555                         else if(equal(optional)) { type = 2; return true; }
2556                         else if(equal(optional)) { type = 3; return true; }
2557                         else if(equal(optional)) { type = 4; return true; }
2558                         else if(equal(optional)) { type = 5; return true; }
2559                         else { type = 6; return true;}
2560                         return false;
2561
2562                 }
2563                 template<typename V> bool encode(V& v) const
2564                 {
2565                         return v(ref_nested());
2566
2567                 }
2568                 protected:
2569                 template<typename V>  bool decode(size_t index, V& v)
2570                 {
2571                         clear();
2572                         switch(index)
2573                         {
2574                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
2575                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
2576                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
2577                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
2578                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
2579                         case 6: type = 6; return v(ref_nested());
2580                         ref_nested().clear();
2581                         }
2582                         return false;
2583
2584                 }
2585                 template<typename V> bool encode(size_t index, V& v) const
2586                 {
2587                         if(index != type) {return false;} return v(ref_nested());
2588
2589                 }
2590                 private:
2591                 size_t type {0};
2592
2593         };
2594
2595 };
2596 /*
2597 CellMeasurementResult-Item ::= SEQUENCE {
2598         cell-ID                                         ECGI,
2599         hWLoadIndicator                         HWLoadIndicator         OPTIONAL,
2600         s1TNLLoadIndicator                      S1TNLLoadIndicator      OPTIONAL,
2601         radioResourceStatus                     RadioResourceStatus     OPTIONAL,
2602         iE-Extensions                           ProtocolExtensionContainer { {CellMeasurementResult-Item-ExtIEs} }      OPTIONAL,
2603         ...
2604 }
2605 */
2606
2607 struct CellMeasurementResult_Item : asn::sequence<5, 0, true, 4>
2608 {
2609         static constexpr const char* name() {return "CellMeasurementResult-Item";}
2610         using parent_t = asn::sequence<5, 0, true, 4>;
2611         struct cell_ID_t : ECGI
2612         {
2613                 static constexpr const char* name() {return "cell_ID_t";}
2614                 using parent_t = ECGI;
2615
2616         };
2617         cell_ID_t& ref_cell_ID() {return cell_ID;}
2618         cell_ID_t const& ref_cell_ID() const {return cell_ID;}
2619         struct hWLoadIndicator_t : HWLoadIndicator
2620         {
2621                 static constexpr const char* name() {return "hWLoadIndicator_t";}
2622                 using parent_t = HWLoadIndicator;
2623                 static constexpr bool optional = true;
2624
2625         };
2626         hWLoadIndicator_t& set_hWLoadIndicator() { hWLoadIndicator.setpresent(true); return hWLoadIndicator;}
2627         hWLoadIndicator_t const* get_hWLoadIndicator() const {return hWLoadIndicator.is_valid() ? &hWLoadIndicator : nullptr;}
2628         struct s1TNLLoadIndicator_t : S1TNLLoadIndicator
2629         {
2630                 static constexpr const char* name() {return "s1TNLLoadIndicator_t";}
2631                 using parent_t = S1TNLLoadIndicator;
2632                 static constexpr bool optional = true;
2633
2634         };
2635         s1TNLLoadIndicator_t& set_s1TNLLoadIndicator() { s1TNLLoadIndicator.setpresent(true); return s1TNLLoadIndicator;}
2636         s1TNLLoadIndicator_t const* get_s1TNLLoadIndicator() const {return s1TNLLoadIndicator.is_valid() ? &s1TNLLoadIndicator : nullptr;}
2637         struct radioResourceStatus_t : RadioResourceStatus
2638         {
2639                 static constexpr const char* name() {return "radioResourceStatus_t";}
2640                 using parent_t = RadioResourceStatus;
2641                 static constexpr bool optional = true;
2642
2643         };
2644         radioResourceStatus_t& set_radioResourceStatus() { radioResourceStatus.setpresent(true); return radioResourceStatus;}
2645         radioResourceStatus_t const* get_radioResourceStatus() const {return radioResourceStatus.is_valid() ? &radioResourceStatus : nullptr;}
2646         struct iE_Extensions_t : ProtocolExtensionContainer<CellMeasurementResult_Item_ExtIEs>
2647         {
2648                 static constexpr const char* name() {return "iE_Extensions_t";}
2649                 using parent_t = ProtocolExtensionContainer<CellMeasurementResult_Item_ExtIEs>;
2650                 static constexpr bool optional = true;
2651
2652         };
2653         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2654         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2655         template<typename V> void decode(V& v)
2656         {
2657                 v(cell_ID);
2658                 v(hWLoadIndicator);
2659                 v(s1TNLLoadIndicator);
2660                 v(radioResourceStatus);
2661                 v(iE_Extensions);
2662
2663         };
2664         template<typename V> void encode(V& v) const
2665         {
2666                 v(cell_ID);
2667                 v(hWLoadIndicator);
2668                 v(s1TNLLoadIndicator);
2669                 v(radioResourceStatus);
2670                 v(iE_Extensions);
2671
2672         };
2673         void clear()
2674         {
2675                 cell_ID.clear();
2676                 hWLoadIndicator.clear();
2677                 s1TNLLoadIndicator.clear();
2678                 radioResourceStatus.clear();
2679                 iE_Extensions.clear();
2680
2681         };
2682         private:
2683         cell_ID_t       cell_ID;
2684         hWLoadIndicator_t       hWLoadIndicator;
2685         s1TNLLoadIndicator_t    s1TNLLoadIndicator;
2686         radioResourceStatus_t   radioResourceStatus;
2687         iE_Extensions_t iE_Extensions;
2688
2689 };
2690 /*
2691 CellMeasurementResult-ItemIEs X2AP-PROTOCOL-IES ::= {
2692         { ID id-CellMeasurementResult-Item      CRITICALITY ignore      TYPE CellMeasurementResult-Item PRESENCE mandatory}
2693 }
2694 */
2695
2696 struct CellMeasurementResult_ItemIEs
2697 {
2698         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
2699         {
2700                 size_t get_index() const {return type;}
2701                 void clear() {type = 0;}
2702                 void select_id_CellMeasurementResult_Item() { set(id_CellMeasurementResult_Item); type=1;}
2703                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
2704                 template<typename V>  bool decode(V& v)
2705                 {
2706                         clear();
2707                         if(!v(ref_nested())) return false;
2708                         if(equal(id_CellMeasurementResult_Item)) { type = 1; return true; }
2709                         return false;
2710
2711                 }
2712                 template<typename V> bool encode(V& v) const
2713                 {
2714                         return v(ref_nested());
2715
2716                 }
2717                 protected:
2718                 template<typename V>  bool decode(size_t index, V& v)
2719                 {
2720                         clear();
2721                         switch(index)
2722                         {
2723                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CellMeasurementResult_Item);} return false;
2724                         ref_nested().clear();
2725                         }
2726                         return false;
2727
2728                 }
2729                 template<typename V> bool encode(size_t index, V& v) const
2730                 {
2731                         if(index != type) {return false;} return v(ref_nested());
2732
2733                 }
2734                 private:
2735                 size_t type {0};
2736
2737         };
2738         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
2739         {
2740                 size_t get_index() const {return type;}
2741                 void clear() {type = 0;}
2742                 void select_id_CellMeasurementResult_Item() { set(ignore); type=1;}
2743                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
2744                 template<typename V>  bool decode(V& v)
2745                 {
2746                         clear();
2747                         if(!v(ref_nested())) return false;
2748                         if(equal(ignore)) { type = 1; return true; }
2749                         return false;
2750
2751                 }
2752                 template<typename V> bool encode(V& v) const
2753                 {
2754                         return v(ref_nested());
2755
2756                 }
2757                 protected:
2758                 template<typename V>  bool decode(size_t index, V& v)
2759                 {
2760                         clear();
2761                         switch(index)
2762                         {
2763                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
2764                         ref_nested().clear();
2765                         }
2766                         return false;
2767
2768                 }
2769                 template<typename V> bool encode(size_t index, V& v) const
2770                 {
2771                         if(index != type) {return false;} return v(ref_nested());
2772
2773                 }
2774                 private:
2775                 size_t type {0};
2776
2777         };
2778         struct Value_t : asn::typefield<false>
2779         {
2780                 ~Value_t()      {clear();}
2781                 size_t get_index() const {return type;}
2782                 CellMeasurementResult_Item& select_id_CellMeasurementResult_Item() { return set<CellMeasurementResult_Item>(1); }
2783                 CellMeasurementResult_Item const* get_id_CellMeasurementResult_Item() const { return get<CellMeasurementResult_Item>(1); }
2784                 void clear()
2785                 {
2786                         switch(type)
2787                         {
2788                         case 1: var.destroy<CellMeasurementResult_Item>(); break;
2789                         }
2790                         type = 0; ref_nested().clear();
2791                 }
2792                 template<typename V> static inline void enumerate(V& v)
2793                 {
2794                         v.template operator()<CellMeasurementResult_Item>(1);
2795
2796                 }
2797                 protected:
2798                 template<typename V> bool decode(size_t index, V& v)
2799                 {
2800                         clear();
2801                         switch(index)
2802                         {
2803                         case 1: v(select_id_CellMeasurementResult_Item()); return true;
2804                         }
2805                         return false;
2806
2807                 }
2808                 template<typename V> bool encode(size_t index, V& v) const
2809                 {
2810                         if(index != type) return false;
2811                         switch(type)
2812                         {
2813                         case 1: v(var.as<CellMeasurementResult_Item>()); return true;
2814                         }
2815                         return false;
2816
2817                 }
2818                 private:
2819                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
2820                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
2821                 union union_type
2822                 {
2823                         char dummy1[sizeof(CellMeasurementResult_Item)];
2824
2825                 };
2826                 asn::variant<sizeof(union_type)> var;
2827                 size_t type {0};
2828
2829         };
2830         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
2831         {
2832                 size_t get_index() const {return type;}
2833                 void clear() {type = 0;}
2834                 void select_id_CellMeasurementResult_Item() { set(mandatory); type=1;}
2835                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
2836                 template<typename V>  bool decode(V& v)
2837                 {
2838                         clear();
2839                         if(!v(ref_nested())) return false;
2840                         if(equal(mandatory)) { type = 1; return true; }
2841                         return false;
2842
2843                 }
2844                 template<typename V> bool encode(V& v) const
2845                 {
2846                         return v(ref_nested());
2847
2848                 }
2849                 protected:
2850                 template<typename V>  bool decode(size_t index, V& v)
2851                 {
2852                         clear();
2853                         switch(index)
2854                         {
2855                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
2856                         ref_nested().clear();
2857                         }
2858                         return false;
2859
2860                 }
2861                 template<typename V> bool encode(size_t index, V& v) const
2862                 {
2863                         if(index != type) {return false;} return v(ref_nested());
2864
2865                 }
2866                 private:
2867                 size_t type {0};
2868
2869         };
2870
2871 };
2872 /*
2873 CellMeasurementResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellMeasurementResult-ItemIEs} }
2874 */
2875
2876 struct CellMeasurementResult_List_elm : ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>
2877 {
2878         static constexpr const char* name() {return "CellMeasurementResult_List_elm";}
2879         using parent_t = ProtocolIE_Single_Container<CellMeasurementResult_ItemIEs>;
2880
2881 };
2882 struct CellMeasurementResult_List : asn::sequenceof<CellMeasurementResult_List_elm>
2883 {
2884         static constexpr const char* name() {return "CellMeasurementResult-List";}
2885         using parent_t = asn::sequenceof<CellMeasurementResult_List_elm>;
2886         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
2887
2888 };
2889 /*
2890 CellToReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2891         ...
2892 }
2893 */
2894
2895 struct CellToReport_Item_ExtIEs
2896 {
2897         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2898         {
2899                 size_t get_index() const {return type;}
2900                 bool is_unknown() const { return type == 1; }
2901                 void clear() {type = 0;}
2902                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2903                 template<typename V>  bool decode(V& v)
2904                 {
2905                         clear();
2906                         if(!v(ref_nested())) return false;
2907                         { type = 1; return true;}
2908                         return false;
2909
2910                 }
2911                 template<typename V> bool encode(V& v) const
2912                 {
2913                         return v(ref_nested());
2914
2915                 }
2916                 protected:
2917                 template<typename V>  bool decode(size_t index, V& v)
2918                 {
2919                         clear();
2920                         switch(index)
2921                         {
2922                         case 1: type = 1; return v(ref_nested());
2923                         ref_nested().clear();
2924                         }
2925                         return false;
2926
2927                 }
2928                 template<typename V> bool encode(size_t index, V& v) const
2929                 {
2930                         if(index != type) {return false;} return v(ref_nested());
2931
2932                 }
2933                 private:
2934                 size_t type {0};
2935
2936         };
2937         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2938         {
2939                 size_t get_index() const {return type;}
2940                 bool is_unknown() const { return type == 1; }
2941                 void clear() {type = 0;}
2942                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2943                 template<typename V>  bool decode(V& v)
2944                 {
2945                         clear();
2946                         if(!v(ref_nested())) return false;
2947                         { type = 1; return true;}
2948                         return false;
2949
2950                 }
2951                 template<typename V> bool encode(V& v) const
2952                 {
2953                         return v(ref_nested());
2954
2955                 }
2956                 protected:
2957                 template<typename V>  bool decode(size_t index, V& v)
2958                 {
2959                         clear();
2960                         switch(index)
2961                         {
2962                         case 1: type = 1; return v(ref_nested());
2963                         ref_nested().clear();
2964                         }
2965                         return false;
2966
2967                 }
2968                 template<typename V> bool encode(size_t index, V& v) const
2969                 {
2970                         if(index != type) {return false;} return v(ref_nested());
2971
2972                 }
2973                 private:
2974                 size_t type {0};
2975
2976         };
2977         struct Extension_t : asn::typefield<true>
2978         {
2979                 ~Extension_t()  {clear();}
2980                 size_t get_index() const {return type;}
2981                 bool is_unknown() const { return type == 1; }
2982                 void clear()
2983                 {
2984                         type = 0; ref_nested().clear();
2985                 }
2986                 template<typename V> static inline void enumerate(V& v)
2987                 {
2988
2989                 }
2990                 protected:
2991                 template<typename V> bool decode(size_t index, V& v)
2992                 {
2993                         clear();
2994                         switch(index)
2995                         {
2996                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2997                         }
2998                         return false;
2999
3000                 }
3001                 template<typename V> bool encode(size_t index, V& v) const
3002                 {
3003                         if(index != type) return false;
3004                         return false;
3005
3006                 }
3007                 private:
3008                 size_t type {0};
3009
3010         };
3011         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3012         {
3013                 size_t get_index() const {return type;}
3014                 bool is_unknown() const { return type == 1; }
3015                 void clear() {type = 0;}
3016                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3017                 template<typename V>  bool decode(V& v)
3018                 {
3019                         clear();
3020                         if(!v(ref_nested())) return false;
3021                         { type = 1; return true;}
3022                         return false;
3023
3024                 }
3025                 template<typename V> bool encode(V& v) const
3026                 {
3027                         return v(ref_nested());
3028
3029                 }
3030                 protected:
3031                 template<typename V>  bool decode(size_t index, V& v)
3032                 {
3033                         clear();
3034                         switch(index)
3035                         {
3036                         case 1: type = 1; return v(ref_nested());
3037                         ref_nested().clear();
3038                         }
3039                         return false;
3040
3041                 }
3042                 template<typename V> bool encode(size_t index, V& v) const
3043                 {
3044                         if(index != type) {return false;} return v(ref_nested());
3045
3046                 }
3047                 private:
3048                 size_t type {0};
3049
3050         };
3051
3052 };
3053 /*
3054 CellToReport-Item ::= SEQUENCE {
3055         cell-ID                                                                 ECGI,
3056         iE-Extensions                                                   ProtocolExtensionContainer { {CellToReport-Item-ExtIEs} } OPTIONAL,
3057         ...
3058 }
3059 */
3060
3061 struct CellToReport_Item : asn::sequence<2, 0, true, 1>
3062 {
3063         static constexpr const char* name() {return "CellToReport-Item";}
3064         using parent_t = asn::sequence<2, 0, true, 1>;
3065         struct cell_ID_t : ECGI
3066         {
3067                 static constexpr const char* name() {return "cell_ID_t";}
3068                 using parent_t = ECGI;
3069
3070         };
3071         cell_ID_t& ref_cell_ID() {return cell_ID;}
3072         cell_ID_t const& ref_cell_ID() const {return cell_ID;}
3073         struct iE_Extensions_t : ProtocolExtensionContainer<CellToReport_Item_ExtIEs>
3074         {
3075                 static constexpr const char* name() {return "iE_Extensions_t";}
3076                 using parent_t = ProtocolExtensionContainer<CellToReport_Item_ExtIEs>;
3077                 static constexpr bool optional = true;
3078
3079         };
3080         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3081         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3082         template<typename V> void decode(V& v)
3083         {
3084                 v(cell_ID);
3085                 v(iE_Extensions);
3086
3087         };
3088         template<typename V> void encode(V& v) const
3089         {
3090                 v(cell_ID);
3091                 v(iE_Extensions);
3092
3093         };
3094         void clear()
3095         {
3096                 cell_ID.clear();
3097                 iE_Extensions.clear();
3098
3099         };
3100         private:
3101         cell_ID_t       cell_ID;
3102         iE_Extensions_t iE_Extensions;
3103
3104 };
3105 /*
3106 CellToReport-ItemIEs X2AP-PROTOCOL-IES ::= {
3107         { ID id-CellToReport-Item       CRITICALITY ignore      TYPE CellToReport-Item  PRESENCE mandatory}
3108 }
3109 */
3110
3111 struct CellToReport_ItemIEs
3112 {
3113         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3114         {
3115                 size_t get_index() const {return type;}
3116                 void clear() {type = 0;}
3117                 void select_id_CellToReport_Item() { set(id_CellToReport_Item); type=1;}
3118                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3119                 template<typename V>  bool decode(V& v)
3120                 {
3121                         clear();
3122                         if(!v(ref_nested())) return false;
3123                         if(equal(id_CellToReport_Item)) { type = 1; return true; }
3124                         return false;
3125
3126                 }
3127                 template<typename V> bool encode(V& v) const
3128                 {
3129                         return v(ref_nested());
3130
3131                 }
3132                 protected:
3133                 template<typename V>  bool decode(size_t index, V& v)
3134                 {
3135                         clear();
3136                         switch(index)
3137                         {
3138                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CellToReport_Item);} return false;
3139                         ref_nested().clear();
3140                         }
3141                         return false;
3142
3143                 }
3144                 template<typename V> bool encode(size_t index, V& v) const
3145                 {
3146                         if(index != type) {return false;} return v(ref_nested());
3147
3148                 }
3149                 private:
3150                 size_t type {0};
3151
3152         };
3153         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
3154         {
3155                 size_t get_index() const {return type;}
3156                 void clear() {type = 0;}
3157                 void select_id_CellToReport_Item() { set(ignore); type=1;}
3158                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
3159                 template<typename V>  bool decode(V& v)
3160                 {
3161                         clear();
3162                         if(!v(ref_nested())) return false;
3163                         if(equal(ignore)) { type = 1; return true; }
3164                         return false;
3165
3166                 }
3167                 template<typename V> bool encode(V& v) const
3168                 {
3169                         return v(ref_nested());
3170
3171                 }
3172                 protected:
3173                 template<typename V>  bool decode(size_t index, V& v)
3174                 {
3175                         clear();
3176                         switch(index)
3177                         {
3178                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
3179                         ref_nested().clear();
3180                         }
3181                         return false;
3182
3183                 }
3184                 template<typename V> bool encode(size_t index, V& v) const
3185                 {
3186                         if(index != type) {return false;} return v(ref_nested());
3187
3188                 }
3189                 private:
3190                 size_t type {0};
3191
3192         };
3193         struct Value_t : asn::typefield<false>
3194         {
3195                 ~Value_t()      {clear();}
3196                 size_t get_index() const {return type;}
3197                 CellToReport_Item& select_id_CellToReport_Item() { return set<CellToReport_Item>(1); }
3198                 CellToReport_Item const* get_id_CellToReport_Item() const { return get<CellToReport_Item>(1); }
3199                 void clear()
3200                 {
3201                         switch(type)
3202                         {
3203                         case 1: var.destroy<CellToReport_Item>(); break;
3204                         }
3205                         type = 0; ref_nested().clear();
3206                 }
3207                 template<typename V> static inline void enumerate(V& v)
3208                 {
3209                         v.template operator()<CellToReport_Item>(1);
3210
3211                 }
3212                 protected:
3213                 template<typename V> bool decode(size_t index, V& v)
3214                 {
3215                         clear();
3216                         switch(index)
3217                         {
3218                         case 1: v(select_id_CellToReport_Item()); return true;
3219                         }
3220                         return false;
3221
3222                 }
3223                 template<typename V> bool encode(size_t index, V& v) const
3224                 {
3225                         if(index != type) return false;
3226                         switch(type)
3227                         {
3228                         case 1: v(var.as<CellToReport_Item>()); return true;
3229                         }
3230                         return false;
3231
3232                 }
3233                 private:
3234                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
3235                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
3236                 union union_type
3237                 {
3238                         char dummy1[sizeof(CellToReport_Item)];
3239
3240                 };
3241                 asn::variant<sizeof(union_type)> var;
3242                 size_t type {0};
3243
3244         };
3245         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
3246         {
3247                 size_t get_index() const {return type;}
3248                 void clear() {type = 0;}
3249                 void select_id_CellToReport_Item() { set(mandatory); type=1;}
3250                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
3251                 template<typename V>  bool decode(V& v)
3252                 {
3253                         clear();
3254                         if(!v(ref_nested())) return false;
3255                         if(equal(mandatory)) { type = 1; return true; }
3256                         return false;
3257
3258                 }
3259                 template<typename V> bool encode(V& v) const
3260                 {
3261                         return v(ref_nested());
3262
3263                 }
3264                 protected:
3265                 template<typename V>  bool decode(size_t index, V& v)
3266                 {
3267                         clear();
3268                         switch(index)
3269                         {
3270                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
3271                         ref_nested().clear();
3272                         }
3273                         return false;
3274
3275                 }
3276                 template<typename V> bool encode(size_t index, V& v) const
3277                 {
3278                         if(index != type) {return false;} return v(ref_nested());
3279
3280                 }
3281                 private:
3282                 size_t type {0};
3283
3284         };
3285
3286 };
3287 /*
3288 CellToReport-List               ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CellToReport-ItemIEs} }
3289 */
3290
3291 struct CellToReport_List_elm : ProtocolIE_Single_Container<CellToReport_ItemIEs>
3292 {
3293         static constexpr const char* name() {return "CellToReport_List_elm";}
3294         using parent_t = ProtocolIE_Single_Container<CellToReport_ItemIEs>;
3295
3296 };
3297 struct CellToReport_List : asn::sequenceof<CellToReport_List_elm>
3298 {
3299         static constexpr const char* name() {return "CellToReport-List";}
3300         using parent_t = asn::sequenceof<CellToReport_List_elm>;
3301         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
3302
3303 };
3304 /*
3305 MeasurementFailureCause-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3306         ...
3307 }
3308 */
3309
3310 struct MeasurementFailureCause_Item_ExtIEs
3311 {
3312         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3313         {
3314                 size_t get_index() const {return type;}
3315                 bool is_unknown() const { return type == 1; }
3316                 void clear() {type = 0;}
3317                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3318                 template<typename V>  bool decode(V& v)
3319                 {
3320                         clear();
3321                         if(!v(ref_nested())) return false;
3322                         { type = 1; return true;}
3323                         return false;
3324
3325                 }
3326                 template<typename V> bool encode(V& v) const
3327                 {
3328                         return v(ref_nested());
3329
3330                 }
3331                 protected:
3332                 template<typename V>  bool decode(size_t index, V& v)
3333                 {
3334                         clear();
3335                         switch(index)
3336                         {
3337                         case 1: type = 1; return v(ref_nested());
3338                         ref_nested().clear();
3339                         }
3340                         return false;
3341
3342                 }
3343                 template<typename V> bool encode(size_t index, V& v) const
3344                 {
3345                         if(index != type) {return false;} return v(ref_nested());
3346
3347                 }
3348                 private:
3349                 size_t type {0};
3350
3351         };
3352         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3353         {
3354                 size_t get_index() const {return type;}
3355                 bool is_unknown() const { return type == 1; }
3356                 void clear() {type = 0;}
3357                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3358                 template<typename V>  bool decode(V& v)
3359                 {
3360                         clear();
3361                         if(!v(ref_nested())) return false;
3362                         { type = 1; return true;}
3363                         return false;
3364
3365                 }
3366                 template<typename V> bool encode(V& v) const
3367                 {
3368                         return v(ref_nested());
3369
3370                 }
3371                 protected:
3372                 template<typename V>  bool decode(size_t index, V& v)
3373                 {
3374                         clear();
3375                         switch(index)
3376                         {
3377                         case 1: type = 1; return v(ref_nested());
3378                         ref_nested().clear();
3379                         }
3380                         return false;
3381
3382                 }
3383                 template<typename V> bool encode(size_t index, V& v) const
3384                 {
3385                         if(index != type) {return false;} return v(ref_nested());
3386
3387                 }
3388                 private:
3389                 size_t type {0};
3390
3391         };
3392         struct Extension_t : asn::typefield<true>
3393         {
3394                 ~Extension_t()  {clear();}
3395                 size_t get_index() const {return type;}
3396                 bool is_unknown() const { return type == 1; }
3397                 void clear()
3398                 {
3399                         type = 0; ref_nested().clear();
3400                 }
3401                 template<typename V> static inline void enumerate(V& v)
3402                 {
3403
3404                 }
3405                 protected:
3406                 template<typename V> bool decode(size_t index, V& v)
3407                 {
3408                         clear();
3409                         switch(index)
3410                         {
3411                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3412                         }
3413                         return false;
3414
3415                 }
3416                 template<typename V> bool encode(size_t index, V& v) const
3417                 {
3418                         if(index != type) return false;
3419                         return false;
3420
3421                 }
3422                 private:
3423                 size_t type {0};
3424
3425         };
3426         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3427         {
3428                 size_t get_index() const {return type;}
3429                 bool is_unknown() const { return type == 1; }
3430                 void clear() {type = 0;}
3431                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3432                 template<typename V>  bool decode(V& v)
3433                 {
3434                         clear();
3435                         if(!v(ref_nested())) return false;
3436                         { type = 1; return true;}
3437                         return false;
3438
3439                 }
3440                 template<typename V> bool encode(V& v) const
3441                 {
3442                         return v(ref_nested());
3443
3444                 }
3445                 protected:
3446                 template<typename V>  bool decode(size_t index, V& v)
3447                 {
3448                         clear();
3449                         switch(index)
3450                         {
3451                         case 1: type = 1; return v(ref_nested());
3452                         ref_nested().clear();
3453                         }
3454                         return false;
3455
3456                 }
3457                 template<typename V> bool encode(size_t index, V& v) const
3458                 {
3459                         if(index != type) {return false;} return v(ref_nested());
3460
3461                 }
3462                 private:
3463                 size_t type {0};
3464
3465         };
3466
3467 };
3468 /*
3469 MeasurementFailureCause-Item ::= SEQUENCE {
3470         measurementFailedReportCharacteristics                  ReportCharacteristics,
3471         cause                                                                                   Cause,
3472         iE-Extensions                                                                   ProtocolExtensionContainer { {MeasurementFailureCause-Item-ExtIEs} }    OPTIONAL,
3473         ...
3474 }
3475 */
3476
3477 struct MeasurementFailureCause_Item : asn::sequence<3, 0, true, 1>
3478 {
3479         static constexpr const char* name() {return "MeasurementFailureCause-Item";}
3480         using parent_t = asn::sequence<3, 0, true, 1>;
3481         struct measurementFailedReportCharacteristics_t : ReportCharacteristics
3482         {
3483                 static constexpr const char* name() {return "measurementFailedReportCharacteristics_t";}
3484                 using parent_t = ReportCharacteristics;
3485
3486         };
3487         measurementFailedReportCharacteristics_t& ref_measurementFailedReportCharacteristics() {return measurementFailedReportCharacteristics;}
3488         measurementFailedReportCharacteristics_t const& ref_measurementFailedReportCharacteristics() const {return measurementFailedReportCharacteristics;}
3489         struct cause_t : Cause
3490         {
3491                 static constexpr const char* name() {return "cause_t";}
3492                 using parent_t = Cause;
3493
3494         };
3495         cause_t& ref_cause() {return cause;}
3496         cause_t const& ref_cause() const {return cause;}
3497         struct iE_Extensions_t : ProtocolExtensionContainer<MeasurementFailureCause_Item_ExtIEs>
3498         {
3499                 static constexpr const char* name() {return "iE_Extensions_t";}
3500                 using parent_t = ProtocolExtensionContainer<MeasurementFailureCause_Item_ExtIEs>;
3501                 static constexpr bool optional = true;
3502
3503         };
3504         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3505         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3506         template<typename V> void decode(V& v)
3507         {
3508                 v(measurementFailedReportCharacteristics);
3509                 v(cause);
3510                 v(iE_Extensions);
3511
3512         };
3513         template<typename V> void encode(V& v) const
3514         {
3515                 v(measurementFailedReportCharacteristics);
3516                 v(cause);
3517                 v(iE_Extensions);
3518
3519         };
3520         void clear()
3521         {
3522                 measurementFailedReportCharacteristics.clear();
3523                 cause.clear();
3524                 iE_Extensions.clear();
3525
3526         };
3527         private:
3528         measurementFailedReportCharacteristics_t        measurementFailedReportCharacteristics;
3529         cause_t cause;
3530         iE_Extensions_t iE_Extensions;
3531
3532 };
3533 /*
3534 MeasurementFailureCause-ItemIEs X2AP-PROTOCOL-IES ::= {
3535         { ID id-MeasurementFailureCause-Item    CRITICALITY ignore      TYPE MeasurementFailureCause-Item               PRESENCE mandatory}
3536 }
3537 */
3538
3539 struct MeasurementFailureCause_ItemIEs
3540 {
3541         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3542         {
3543                 size_t get_index() const {return type;}
3544                 void clear() {type = 0;}
3545                 void select_id_MeasurementFailureCause_Item() { set(id_MeasurementFailureCause_Item); type=1;}
3546                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3547                 template<typename V>  bool decode(V& v)
3548                 {
3549                         clear();
3550                         if(!v(ref_nested())) return false;
3551                         if(equal(id_MeasurementFailureCause_Item)) { type = 1; return true; }
3552                         return false;
3553
3554                 }
3555                 template<typename V> bool encode(V& v) const
3556                 {
3557                         return v(ref_nested());
3558
3559                 }
3560                 protected:
3561                 template<typename V>  bool decode(size_t index, V& v)
3562                 {
3563                         clear();
3564                         switch(index)
3565                         {
3566                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeasurementFailureCause_Item);} return false;
3567                         ref_nested().clear();
3568                         }
3569                         return false;
3570
3571                 }
3572                 template<typename V> bool encode(size_t index, V& v) const
3573                 {
3574                         if(index != type) {return false;} return v(ref_nested());
3575
3576                 }
3577                 private:
3578                 size_t type {0};
3579
3580         };
3581         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
3582         {
3583                 size_t get_index() const {return type;}
3584                 void clear() {type = 0;}
3585                 void select_id_MeasurementFailureCause_Item() { set(ignore); type=1;}
3586                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
3587                 template<typename V>  bool decode(V& v)
3588                 {
3589                         clear();
3590                         if(!v(ref_nested())) return false;
3591                         if(equal(ignore)) { type = 1; return true; }
3592                         return false;
3593
3594                 }
3595                 template<typename V> bool encode(V& v) const
3596                 {
3597                         return v(ref_nested());
3598
3599                 }
3600                 protected:
3601                 template<typename V>  bool decode(size_t index, V& v)
3602                 {
3603                         clear();
3604                         switch(index)
3605                         {
3606                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
3607                         ref_nested().clear();
3608                         }
3609                         return false;
3610
3611                 }
3612                 template<typename V> bool encode(size_t index, V& v) const
3613                 {
3614                         if(index != type) {return false;} return v(ref_nested());
3615
3616                 }
3617                 private:
3618                 size_t type {0};
3619
3620         };
3621         struct Value_t : asn::typefield<false>
3622         {
3623                 ~Value_t()      {clear();}
3624                 size_t get_index() const {return type;}
3625                 MeasurementFailureCause_Item& select_id_MeasurementFailureCause_Item() { return set<MeasurementFailureCause_Item>(1); }
3626                 MeasurementFailureCause_Item const* get_id_MeasurementFailureCause_Item() const { return get<MeasurementFailureCause_Item>(1); }
3627                 void clear()
3628                 {
3629                         switch(type)
3630                         {
3631                         case 1: var.destroy<MeasurementFailureCause_Item>(); break;
3632                         }
3633                         type = 0; ref_nested().clear();
3634                 }
3635                 template<typename V> static inline void enumerate(V& v)
3636                 {
3637                         v.template operator()<MeasurementFailureCause_Item>(1);
3638
3639                 }
3640                 protected:
3641                 template<typename V> bool decode(size_t index, V& v)
3642                 {
3643                         clear();
3644                         switch(index)
3645                         {
3646                         case 1: v(select_id_MeasurementFailureCause_Item()); return true;
3647                         }
3648                         return false;
3649
3650                 }
3651                 template<typename V> bool encode(size_t index, V& v) const
3652                 {
3653                         if(index != type) return false;
3654                         switch(type)
3655                         {
3656                         case 1: v(var.as<MeasurementFailureCause_Item>()); return true;
3657                         }
3658                         return false;
3659
3660                 }
3661                 private:
3662                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
3663                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
3664                 union union_type
3665                 {
3666                         char dummy1[sizeof(MeasurementFailureCause_Item)];
3667
3668                 };
3669                 asn::variant<sizeof(union_type)> var;
3670                 size_t type {0};
3671
3672         };
3673         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
3674         {
3675                 size_t get_index() const {return type;}
3676                 void clear() {type = 0;}
3677                 void select_id_MeasurementFailureCause_Item() { set(mandatory); type=1;}
3678                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
3679                 template<typename V>  bool decode(V& v)
3680                 {
3681                         clear();
3682                         if(!v(ref_nested())) return false;
3683                         if(equal(mandatory)) { type = 1; return true; }
3684                         return false;
3685
3686                 }
3687                 template<typename V> bool encode(V& v) const
3688                 {
3689                         return v(ref_nested());
3690
3691                 }
3692                 protected:
3693                 template<typename V>  bool decode(size_t index, V& v)
3694                 {
3695                         clear();
3696                         switch(index)
3697                         {
3698                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
3699                         ref_nested().clear();
3700                         }
3701                         return false;
3702
3703                 }
3704                 template<typename V> bool encode(size_t index, V& v) const
3705                 {
3706                         if(index != type) {return false;} return v(ref_nested());
3707
3708                 }
3709                 private:
3710                 size_t type {0};
3711
3712         };
3713
3714 };
3715 /*
3716 MeasurementFailureCause-List ::= SEQUENCE (SIZE (1..maxFailedMeasObjects)) OF ProtocolIE-Single-Container { {MeasurementFailureCause-ItemIEs} }
3717 */
3718
3719 struct MeasurementFailureCause_List_elm : ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>
3720 {
3721         static constexpr const char* name() {return "MeasurementFailureCause_List_elm";}
3722         using parent_t = ProtocolIE_Single_Container<MeasurementFailureCause_ItemIEs>;
3723
3724 };
3725 struct MeasurementFailureCause_List : asn::sequenceof<MeasurementFailureCause_List_elm>
3726 {
3727         static constexpr const char* name() {return "MeasurementFailureCause-List";}
3728         using parent_t = asn::sequenceof<MeasurementFailureCause_List_elm>;
3729         using constraint_t = asn::constraints<false,asn::span<1,  maxFailedMeasObjects >>;
3730
3731 };
3732 /*
3733 CompleteFailureCauseInformation-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3734         ...
3735 }
3736 */
3737
3738 struct CompleteFailureCauseInformation_Item_ExtIEs
3739 {
3740         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3741         {
3742                 size_t get_index() const {return type;}
3743                 bool is_unknown() const { return type == 1; }
3744                 void clear() {type = 0;}
3745                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3746                 template<typename V>  bool decode(V& v)
3747                 {
3748                         clear();
3749                         if(!v(ref_nested())) return false;
3750                         { type = 1; return true;}
3751                         return false;
3752
3753                 }
3754                 template<typename V> bool encode(V& v) const
3755                 {
3756                         return v(ref_nested());
3757
3758                 }
3759                 protected:
3760                 template<typename V>  bool decode(size_t index, V& v)
3761                 {
3762                         clear();
3763                         switch(index)
3764                         {
3765                         case 1: type = 1; return v(ref_nested());
3766                         ref_nested().clear();
3767                         }
3768                         return false;
3769
3770                 }
3771                 template<typename V> bool encode(size_t index, V& v) const
3772                 {
3773                         if(index != type) {return false;} return v(ref_nested());
3774
3775                 }
3776                 private:
3777                 size_t type {0};
3778
3779         };
3780         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3781         {
3782                 size_t get_index() const {return type;}
3783                 bool is_unknown() const { return type == 1; }
3784                 void clear() {type = 0;}
3785                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3786                 template<typename V>  bool decode(V& v)
3787                 {
3788                         clear();
3789                         if(!v(ref_nested())) return false;
3790                         { type = 1; return true;}
3791                         return false;
3792
3793                 }
3794                 template<typename V> bool encode(V& v) const
3795                 {
3796                         return v(ref_nested());
3797
3798                 }
3799                 protected:
3800                 template<typename V>  bool decode(size_t index, V& v)
3801                 {
3802                         clear();
3803                         switch(index)
3804                         {
3805                         case 1: type = 1; return v(ref_nested());
3806                         ref_nested().clear();
3807                         }
3808                         return false;
3809
3810                 }
3811                 template<typename V> bool encode(size_t index, V& v) const
3812                 {
3813                         if(index != type) {return false;} return v(ref_nested());
3814
3815                 }
3816                 private:
3817                 size_t type {0};
3818
3819         };
3820         struct Extension_t : asn::typefield<true>
3821         {
3822                 ~Extension_t()  {clear();}
3823                 size_t get_index() const {return type;}
3824                 bool is_unknown() const { return type == 1; }
3825                 void clear()
3826                 {
3827                         type = 0; ref_nested().clear();
3828                 }
3829                 template<typename V> static inline void enumerate(V& v)
3830                 {
3831
3832                 }
3833                 protected:
3834                 template<typename V> bool decode(size_t index, V& v)
3835                 {
3836                         clear();
3837                         switch(index)
3838                         {
3839                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3840                         }
3841                         return false;
3842
3843                 }
3844                 template<typename V> bool encode(size_t index, V& v) const
3845                 {
3846                         if(index != type) return false;
3847                         return false;
3848
3849                 }
3850                 private:
3851                 size_t type {0};
3852
3853         };
3854         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3855         {
3856                 size_t get_index() const {return type;}
3857                 bool is_unknown() const { return type == 1; }
3858                 void clear() {type = 0;}
3859                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3860                 template<typename V>  bool decode(V& v)
3861                 {
3862                         clear();
3863                         if(!v(ref_nested())) return false;
3864                         { type = 1; return true;}
3865                         return false;
3866
3867                 }
3868                 template<typename V> bool encode(V& v) const
3869                 {
3870                         return v(ref_nested());
3871
3872                 }
3873                 protected:
3874                 template<typename V>  bool decode(size_t index, V& v)
3875                 {
3876                         clear();
3877                         switch(index)
3878                         {
3879                         case 1: type = 1; return v(ref_nested());
3880                         ref_nested().clear();
3881                         }
3882                         return false;
3883
3884                 }
3885                 template<typename V> bool encode(size_t index, V& v) const
3886                 {
3887                         if(index != type) {return false;} return v(ref_nested());
3888
3889                 }
3890                 private:
3891                 size_t type {0};
3892
3893         };
3894
3895 };
3896 /*
3897 CompleteFailureCauseInformation-Item ::= SEQUENCE {
3898         cell-ID                                                                                 ECGI,
3899         measurementFailureCause-List                                    MeasurementFailureCause-List,
3900         iE-Extensions                                                                   ProtocolExtensionContainer { {CompleteFailureCauseInformation-Item-ExtIEs} }    OPTIONAL,
3901         ...
3902 }
3903 */
3904
3905 struct CompleteFailureCauseInformation_Item : asn::sequence<3, 0, true, 1>
3906 {
3907         static constexpr const char* name() {return "CompleteFailureCauseInformation-Item";}
3908         using parent_t = asn::sequence<3, 0, true, 1>;
3909         struct cell_ID_t : ECGI
3910         {
3911                 static constexpr const char* name() {return "cell_ID_t";}
3912                 using parent_t = ECGI;
3913
3914         };
3915         cell_ID_t& ref_cell_ID() {return cell_ID;}
3916         cell_ID_t const& ref_cell_ID() const {return cell_ID;}
3917         struct measurementFailureCause_List_t : MeasurementFailureCause_List
3918         {
3919                 static constexpr const char* name() {return "measurementFailureCause_List_t";}
3920                 using parent_t = MeasurementFailureCause_List;
3921
3922         };
3923         measurementFailureCause_List_t& ref_measurementFailureCause_List() {return measurementFailureCause_List;}
3924         measurementFailureCause_List_t const& ref_measurementFailureCause_List() const {return measurementFailureCause_List;}
3925         struct iE_Extensions_t : ProtocolExtensionContainer<CompleteFailureCauseInformation_Item_ExtIEs>
3926         {
3927                 static constexpr const char* name() {return "iE_Extensions_t";}
3928                 using parent_t = ProtocolExtensionContainer<CompleteFailureCauseInformation_Item_ExtIEs>;
3929                 static constexpr bool optional = true;
3930
3931         };
3932         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3933         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3934         template<typename V> void decode(V& v)
3935         {
3936                 v(cell_ID);
3937                 v(measurementFailureCause_List);
3938                 v(iE_Extensions);
3939
3940         };
3941         template<typename V> void encode(V& v) const
3942         {
3943                 v(cell_ID);
3944                 v(measurementFailureCause_List);
3945                 v(iE_Extensions);
3946
3947         };
3948         void clear()
3949         {
3950                 cell_ID.clear();
3951                 measurementFailureCause_List.clear();
3952                 iE_Extensions.clear();
3953
3954         };
3955         private:
3956         cell_ID_t       cell_ID;
3957         measurementFailureCause_List_t  measurementFailureCause_List;
3958         iE_Extensions_t iE_Extensions;
3959
3960 };
3961 /*
3962 CompleteFailureCauseInformation-ItemIEs X2AP-PROTOCOL-IES ::= {
3963         { ID id-CompleteFailureCauseInformation-Item    CRITICALITY ignore      TYPE CompleteFailureCauseInformation-Item       PRESENCE mandatory}
3964 }
3965 */
3966
3967 struct CompleteFailureCauseInformation_ItemIEs
3968 {
3969         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
3970         {
3971                 size_t get_index() const {return type;}
3972                 void clear() {type = 0;}
3973                 void select_id_CompleteFailureCauseInformation_Item() { set(id_CompleteFailureCauseInformation_Item); type=1;}
3974                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
3975                 template<typename V>  bool decode(V& v)
3976                 {
3977                         clear();
3978                         if(!v(ref_nested())) return false;
3979                         if(equal(id_CompleteFailureCauseInformation_Item)) { type = 1; return true; }
3980                         return false;
3981
3982                 }
3983                 template<typename V> bool encode(V& v) const
3984                 {
3985                         return v(ref_nested());
3986
3987                 }
3988                 protected:
3989                 template<typename V>  bool decode(size_t index, V& v)
3990                 {
3991                         clear();
3992                         switch(index)
3993                         {
3994                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CompleteFailureCauseInformation_Item);} return false;
3995                         ref_nested().clear();
3996                         }
3997                         return false;
3998
3999                 }
4000                 template<typename V> bool encode(size_t index, V& v) const
4001                 {
4002                         if(index != type) {return false;} return v(ref_nested());
4003
4004                 }
4005                 private:
4006                 size_t type {0};
4007
4008         };
4009         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
4010         {
4011                 size_t get_index() const {return type;}
4012                 void clear() {type = 0;}
4013                 void select_id_CompleteFailureCauseInformation_Item() { set(ignore); type=1;}
4014                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4015                 template<typename V>  bool decode(V& v)
4016                 {
4017                         clear();
4018                         if(!v(ref_nested())) return false;
4019                         if(equal(ignore)) { type = 1; return true; }
4020                         return false;
4021
4022                 }
4023                 template<typename V> bool encode(V& v) const
4024                 {
4025                         return v(ref_nested());
4026
4027                 }
4028                 protected:
4029                 template<typename V>  bool decode(size_t index, V& v)
4030                 {
4031                         clear();
4032                         switch(index)
4033                         {
4034                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4035                         ref_nested().clear();
4036                         }
4037                         return false;
4038
4039                 }
4040                 template<typename V> bool encode(size_t index, V& v) const
4041                 {
4042                         if(index != type) {return false;} return v(ref_nested());
4043
4044                 }
4045                 private:
4046                 size_t type {0};
4047
4048         };
4049         struct Value_t : asn::typefield<false>
4050         {
4051                 ~Value_t()      {clear();}
4052                 size_t get_index() const {return type;}
4053                 CompleteFailureCauseInformation_Item& select_id_CompleteFailureCauseInformation_Item() { return set<CompleteFailureCauseInformation_Item>(1); }
4054                 CompleteFailureCauseInformation_Item const* get_id_CompleteFailureCauseInformation_Item() const { return get<CompleteFailureCauseInformation_Item>(1); }
4055                 void clear()
4056                 {
4057                         switch(type)
4058                         {
4059                         case 1: var.destroy<CompleteFailureCauseInformation_Item>(); break;
4060                         }
4061                         type = 0; ref_nested().clear();
4062                 }
4063                 template<typename V> static inline void enumerate(V& v)
4064                 {
4065                         v.template operator()<CompleteFailureCauseInformation_Item>(1);
4066
4067                 }
4068                 protected:
4069                 template<typename V> bool decode(size_t index, V& v)
4070                 {
4071                         clear();
4072                         switch(index)
4073                         {
4074                         case 1: v(select_id_CompleteFailureCauseInformation_Item()); return true;
4075                         }
4076                         return false;
4077
4078                 }
4079                 template<typename V> bool encode(size_t index, V& v) const
4080                 {
4081                         if(index != type) return false;
4082                         switch(type)
4083                         {
4084                         case 1: v(var.as<CompleteFailureCauseInformation_Item>()); return true;
4085                         }
4086                         return false;
4087
4088                 }
4089                 private:
4090                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4091                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4092                 union union_type
4093                 {
4094                         char dummy1[sizeof(CompleteFailureCauseInformation_Item)];
4095
4096                 };
4097                 asn::variant<sizeof(union_type)> var;
4098                 size_t type {0};
4099
4100         };
4101         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
4102         {
4103                 size_t get_index() const {return type;}
4104                 void clear() {type = 0;}
4105                 void select_id_CompleteFailureCauseInformation_Item() { set(mandatory); type=1;}
4106                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4107                 template<typename V>  bool decode(V& v)
4108                 {
4109                         clear();
4110                         if(!v(ref_nested())) return false;
4111                         if(equal(mandatory)) { type = 1; return true; }
4112                         return false;
4113
4114                 }
4115                 template<typename V> bool encode(V& v) const
4116                 {
4117                         return v(ref_nested());
4118
4119                 }
4120                 protected:
4121                 template<typename V>  bool decode(size_t index, V& v)
4122                 {
4123                         clear();
4124                         switch(index)
4125                         {
4126                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
4127                         ref_nested().clear();
4128                         }
4129                         return false;
4130
4131                 }
4132                 template<typename V> bool encode(size_t index, V& v) const
4133                 {
4134                         if(index != type) {return false;} return v(ref_nested());
4135
4136                 }
4137                 private:
4138                 size_t type {0};
4139
4140         };
4141
4142 };
4143 /*
4144 CompleteFailureCauseInformation-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {CompleteFailureCauseInformation-ItemIEs} }
4145 */
4146
4147 struct CompleteFailureCauseInformation_List_elm : ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>
4148 {
4149         static constexpr const char* name() {return "CompleteFailureCauseInformation_List_elm";}
4150         using parent_t = ProtocolIE_Single_Container<CompleteFailureCauseInformation_ItemIEs>;
4151
4152 };
4153 struct CompleteFailureCauseInformation_List : asn::sequenceof<CompleteFailureCauseInformation_List_elm>
4154 {
4155         static constexpr const char* name() {return "CompleteFailureCauseInformation-List";}
4156         using parent_t = asn::sequenceof<CompleteFailureCauseInformation_List_elm>;
4157         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
4158
4159 };
4160 /*
4161 E-RABs-DataForwardingAddress-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4162         ...
4163 }
4164 */
4165
4166 struct E_RABs_DataForwardingAddress_ItemExtIEs
4167 {
4168         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4169         {
4170                 size_t get_index() const {return type;}
4171                 bool is_unknown() const { return type == 1; }
4172                 void clear() {type = 0;}
4173                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4174                 template<typename V>  bool decode(V& v)
4175                 {
4176                         clear();
4177                         if(!v(ref_nested())) return false;
4178                         { type = 1; return true;}
4179                         return false;
4180
4181                 }
4182                 template<typename V> bool encode(V& v) const
4183                 {
4184                         return v(ref_nested());
4185
4186                 }
4187                 protected:
4188                 template<typename V>  bool decode(size_t index, V& v)
4189                 {
4190                         clear();
4191                         switch(index)
4192                         {
4193                         case 1: type = 1; return v(ref_nested());
4194                         ref_nested().clear();
4195                         }
4196                         return false;
4197
4198                 }
4199                 template<typename V> bool encode(size_t index, V& v) const
4200                 {
4201                         if(index != type) {return false;} return v(ref_nested());
4202
4203                 }
4204                 private:
4205                 size_t type {0};
4206
4207         };
4208         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4209         {
4210                 size_t get_index() const {return type;}
4211                 bool is_unknown() const { return type == 1; }
4212                 void clear() {type = 0;}
4213                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4214                 template<typename V>  bool decode(V& v)
4215                 {
4216                         clear();
4217                         if(!v(ref_nested())) return false;
4218                         { type = 1; return true;}
4219                         return false;
4220
4221                 }
4222                 template<typename V> bool encode(V& v) const
4223                 {
4224                         return v(ref_nested());
4225
4226                 }
4227                 protected:
4228                 template<typename V>  bool decode(size_t index, V& v)
4229                 {
4230                         clear();
4231                         switch(index)
4232                         {
4233                         case 1: type = 1; return v(ref_nested());
4234                         ref_nested().clear();
4235                         }
4236                         return false;
4237
4238                 }
4239                 template<typename V> bool encode(size_t index, V& v) const
4240                 {
4241                         if(index != type) {return false;} return v(ref_nested());
4242
4243                 }
4244                 private:
4245                 size_t type {0};
4246
4247         };
4248         struct Extension_t : asn::typefield<true>
4249         {
4250                 ~Extension_t()  {clear();}
4251                 size_t get_index() const {return type;}
4252                 bool is_unknown() const { return type == 1; }
4253                 void clear()
4254                 {
4255                         type = 0; ref_nested().clear();
4256                 }
4257                 template<typename V> static inline void enumerate(V& v)
4258                 {
4259
4260                 }
4261                 protected:
4262                 template<typename V> bool decode(size_t index, V& v)
4263                 {
4264                         clear();
4265                         switch(index)
4266                         {
4267                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4268                         }
4269                         return false;
4270
4271                 }
4272                 template<typename V> bool encode(size_t index, V& v) const
4273                 {
4274                         if(index != type) return false;
4275                         return false;
4276
4277                 }
4278                 private:
4279                 size_t type {0};
4280
4281         };
4282         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4283         {
4284                 size_t get_index() const {return type;}
4285                 bool is_unknown() const { return type == 1; }
4286                 void clear() {type = 0;}
4287                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4288                 template<typename V>  bool decode(V& v)
4289                 {
4290                         clear();
4291                         if(!v(ref_nested())) return false;
4292                         { type = 1; return true;}
4293                         return false;
4294
4295                 }
4296                 template<typename V> bool encode(V& v) const
4297                 {
4298                         return v(ref_nested());
4299
4300                 }
4301                 protected:
4302                 template<typename V>  bool decode(size_t index, V& v)
4303                 {
4304                         clear();
4305                         switch(index)
4306                         {
4307                         case 1: type = 1; return v(ref_nested());
4308                         ref_nested().clear();
4309                         }
4310                         return false;
4311
4312                 }
4313                 template<typename V> bool encode(size_t index, V& v) const
4314                 {
4315                         if(index != type) {return false;} return v(ref_nested());
4316
4317                 }
4318                 private:
4319                 size_t type {0};
4320
4321         };
4322
4323 };
4324 /*
4325 E-RABs-DataForwardingAddress-Item ::= SEQUENCE {
4326         e-RAB-ID                                                E-RAB-ID,
4327         dl-GTPtunnelEndpoint                    GTPtunnelEndpoint,
4328         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-DataForwardingAddress-ItemExtIEs} } OPTIONAL,
4329         ...
4330 }
4331 */
4332
4333 struct E_RABs_DataForwardingAddress_Item : asn::sequence<3, 0, true, 1>
4334 {
4335         static constexpr const char* name() {return "E-RABs-DataForwardingAddress-Item";}
4336         using parent_t = asn::sequence<3, 0, true, 1>;
4337         struct e_RAB_ID_t : E_RAB_ID
4338         {
4339                 static constexpr const char* name() {return "e_RAB_ID_t";}
4340                 using parent_t = E_RAB_ID;
4341
4342         };
4343         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
4344         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
4345         struct dl_GTPtunnelEndpoint_t : GTPtunnelEndpoint
4346         {
4347                 static constexpr const char* name() {return "dl_GTPtunnelEndpoint_t";}
4348                 using parent_t = GTPtunnelEndpoint;
4349
4350         };
4351         dl_GTPtunnelEndpoint_t& ref_dl_GTPtunnelEndpoint() {return dl_GTPtunnelEndpoint;}
4352         dl_GTPtunnelEndpoint_t const& ref_dl_GTPtunnelEndpoint() const {return dl_GTPtunnelEndpoint;}
4353         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>
4354         {
4355                 static constexpr const char* name() {return "iE_Extensions_t";}
4356                 using parent_t = ProtocolExtensionContainer<E_RABs_DataForwardingAddress_ItemExtIEs>;
4357                 static constexpr bool optional = true;
4358
4359         };
4360         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4361         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4362         template<typename V> void decode(V& v)
4363         {
4364                 v(e_RAB_ID);
4365                 v(dl_GTPtunnelEndpoint);
4366                 v(iE_Extensions);
4367
4368         };
4369         template<typename V> void encode(V& v) const
4370         {
4371                 v(e_RAB_ID);
4372                 v(dl_GTPtunnelEndpoint);
4373                 v(iE_Extensions);
4374
4375         };
4376         void clear()
4377         {
4378                 e_RAB_ID.clear();
4379                 dl_GTPtunnelEndpoint.clear();
4380                 iE_Extensions.clear();
4381
4382         };
4383         private:
4384         e_RAB_ID_t      e_RAB_ID;
4385         dl_GTPtunnelEndpoint_t  dl_GTPtunnelEndpoint;
4386         iE_Extensions_t iE_Extensions;
4387
4388 };
4389 /*
4390 E-RABs-DataForwardingAddress-ItemIEs    X2AP-PROTOCOL-IES ::= {
4391         { ID id-E-RABs-DataForwardingAddress-Item       CRITICALITY ignore      TYPE E-RABs-DataForwardingAddress-Item  PRESENCE mandatory},
4392         ...
4393 }
4394 */
4395
4396 struct E_RABs_DataForwardingAddress_ItemIEs
4397 {
4398         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
4399         {
4400                 size_t get_index() const {return type;}
4401                 bool is_unknown() const { return type == 2; }
4402                 void clear() {type = 0;}
4403                 void select_id_E_RABs_DataForwardingAddress_Item() { set(id_E_RABs_DataForwardingAddress_Item); type=1;}
4404                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
4405                 template<typename V>  bool decode(V& v)
4406                 {
4407                         clear();
4408                         if(!v(ref_nested())) return false;
4409                         if(equal(id_E_RABs_DataForwardingAddress_Item)) { type = 1; return true; }
4410                         else { type = 2; return true;}
4411                         return false;
4412
4413                 }
4414                 template<typename V> bool encode(V& v) const
4415                 {
4416                         return v(ref_nested());
4417
4418                 }
4419                 protected:
4420                 template<typename V>  bool decode(size_t index, V& v)
4421                 {
4422                         clear();
4423                         switch(index)
4424                         {
4425                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_DataForwardingAddress_Item);} return false;
4426                         case 2: type = 2; return v(ref_nested());
4427                         ref_nested().clear();
4428                         }
4429                         return false;
4430
4431                 }
4432                 template<typename V> bool encode(size_t index, V& v) const
4433                 {
4434                         if(index != type) {return false;} return v(ref_nested());
4435
4436                 }
4437                 private:
4438                 size_t type {0};
4439
4440         };
4441         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
4442         {
4443                 size_t get_index() const {return type;}
4444                 bool is_unknown() const { return type == 2; }
4445                 void clear() {type = 0;}
4446                 void select_id_E_RABs_DataForwardingAddress_Item() { set(ignore); type=1;}
4447                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4448                 template<typename V>  bool decode(V& v)
4449                 {
4450                         clear();
4451                         if(!v(ref_nested())) return false;
4452                         if(equal(ignore)) { type = 1; return true; }
4453                         else { type = 2; return true;}
4454                         return false;
4455
4456                 }
4457                 template<typename V> bool encode(V& v) const
4458                 {
4459                         return v(ref_nested());
4460
4461                 }
4462                 protected:
4463                 template<typename V>  bool decode(size_t index, V& v)
4464                 {
4465                         clear();
4466                         switch(index)
4467                         {
4468                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4469                         case 2: type = 2; return v(ref_nested());
4470                         ref_nested().clear();
4471                         }
4472                         return false;
4473
4474                 }
4475                 template<typename V> bool encode(size_t index, V& v) const
4476                 {
4477                         if(index != type) {return false;} return v(ref_nested());
4478
4479                 }
4480                 private:
4481                 size_t type {0};
4482
4483         };
4484         struct Value_t : asn::typefield<true>
4485         {
4486                 ~Value_t()      {clear();}
4487                 size_t get_index() const {return type;}
4488                 E_RABs_DataForwardingAddress_Item& select_id_E_RABs_DataForwardingAddress_Item() { return set<E_RABs_DataForwardingAddress_Item>(1); }
4489                 E_RABs_DataForwardingAddress_Item const* get_id_E_RABs_DataForwardingAddress_Item() const { return get<E_RABs_DataForwardingAddress_Item>(1); }
4490                 bool is_unknown() const { return type == 2; }
4491                 void clear()
4492                 {
4493                         switch(type)
4494                         {
4495                         case 1: var.destroy<E_RABs_DataForwardingAddress_Item>(); break;
4496                         }
4497                         type = 0; ref_nested().clear();
4498                 }
4499                 template<typename V> static inline void enumerate(V& v)
4500                 {
4501                         v.template operator()<E_RABs_DataForwardingAddress_Item>(1);
4502
4503                 }
4504                 protected:
4505                 template<typename V> bool decode(size_t index, V& v)
4506                 {
4507                         clear();
4508                         switch(index)
4509                         {
4510                         case 1: v(select_id_E_RABs_DataForwardingAddress_Item()); return true;
4511                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
4512                         }
4513                         return false;
4514
4515                 }
4516                 template<typename V> bool encode(size_t index, V& v) const
4517                 {
4518                         if(index != type) return false;
4519                         switch(type)
4520                         {
4521                         case 1: v(var.as<E_RABs_DataForwardingAddress_Item>()); return true;
4522                         }
4523                         return false;
4524
4525                 }
4526                 private:
4527                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4528                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4529                 union union_type
4530                 {
4531                         char dummy1[sizeof(E_RABs_DataForwardingAddress_Item)];
4532
4533                 };
4534                 asn::variant<sizeof(union_type)> var;
4535                 size_t type {0};
4536
4537         };
4538         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
4539         {
4540                 size_t get_index() const {return type;}
4541                 bool is_unknown() const { return type == 2; }
4542                 void clear() {type = 0;}
4543                 void select_id_E_RABs_DataForwardingAddress_Item() { set(mandatory); type=1;}
4544                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4545                 template<typename V>  bool decode(V& v)
4546                 {
4547                         clear();
4548                         if(!v(ref_nested())) return false;
4549                         if(equal(mandatory)) { type = 1; return true; }
4550                         else { type = 2; return true;}
4551                         return false;
4552
4553                 }
4554                 template<typename V> bool encode(V& v) const
4555                 {
4556                         return v(ref_nested());
4557
4558                 }
4559                 protected:
4560                 template<typename V>  bool decode(size_t index, V& v)
4561                 {
4562                         clear();
4563                         switch(index)
4564                         {
4565                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
4566                         case 2: type = 2; return v(ref_nested());
4567                         ref_nested().clear();
4568                         }
4569                         return false;
4570
4571                 }
4572                 template<typename V> bool encode(size_t index, V& v) const
4573                 {
4574                         if(index != type) {return false;} return v(ref_nested());
4575
4576                 }
4577                 private:
4578                 size_t type {0};
4579
4580         };
4581
4582 };
4583 /*
4584 E-RABs-DataForwardingAddress-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-DataForwardingAddress-ItemIEs} }
4585 */
4586
4587 struct E_RABs_DataForwardingAddress_List_elm : ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>
4588 {
4589         static constexpr const char* name() {return "E_RABs_DataForwardingAddress_List_elm";}
4590         using parent_t = ProtocolIE_Single_Container<E_RABs_DataForwardingAddress_ItemIEs>;
4591
4592 };
4593 struct E_RABs_DataForwardingAddress_List : asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>
4594 {
4595         static constexpr const char* name() {return "E-RABs-DataForwardingAddress-List";}
4596         using parent_t = asn::sequenceof<E_RABs_DataForwardingAddress_List_elm>;
4597         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
4598
4599 };
4600 /*
4601 DataForwardingAddressIndication-IEs X2AP-PROTOCOL-IES ::= {
4602         { ID id-New-eNB-UE-X2AP-ID-Extension            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional }|
4603         { ID id-Old-eNB-UE-X2AP-ID                                      CRITICALITY ignore      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
4604         { ID id-Old-eNB-UE-X2AP-ID-Extension            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional }|
4605         { ID id-E-RABs-DataForwardingAddress-List       CRITICALITY ignore      TYPE E-RABs-DataForwardingAddress-List          PRESENCE mandatory},
4606         ...
4607 }
4608 */
4609
4610 struct DataForwardingAddressIndication_IEs
4611 {
4612         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
4613         {
4614                 size_t get_index() const {return type;}
4615                 bool is_unknown() const { return type == 5; }
4616                 void clear() {type = 0;}
4617                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=1;}
4618                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=2;}
4619                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
4620                 void select_id_E_RABs_DataForwardingAddress_List() { set(id_E_RABs_DataForwardingAddress_List); type=4;}
4621                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
4622                 template<typename V>  bool decode(V& v)
4623                 {
4624                         clear();
4625                         if(!v(ref_nested())) return false;
4626                         if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 1; return true; }
4627                         else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 2; return true; }
4628                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
4629                         else if(equal(id_E_RABs_DataForwardingAddress_List)) { type = 4; return true; }
4630                         else { type = 5; return true;}
4631                         return false;
4632
4633                 }
4634                 template<typename V> bool encode(V& v) const
4635                 {
4636                         return v(ref_nested());
4637
4638                 }
4639                 protected:
4640                 template<typename V>  bool decode(size_t index, V& v)
4641                 {
4642                         clear();
4643                         switch(index)
4644                         {
4645                         case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
4646                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
4647                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
4648                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_DataForwardingAddress_List);} return false;
4649                         case 5: type = 5; return v(ref_nested());
4650                         ref_nested().clear();
4651                         }
4652                         return false;
4653
4654                 }
4655                 template<typename V> bool encode(size_t index, V& v) const
4656                 {
4657                         if(index != type) {return false;} return v(ref_nested());
4658
4659                 }
4660                 private:
4661                 size_t type {0};
4662
4663         };
4664         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
4665         {
4666                 size_t get_index() const {return type;}
4667                 bool is_unknown() const { return type == 5; }
4668                 void clear() {type = 0;}
4669                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=1;}
4670                 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=2;}
4671                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=3;}
4672                 void select_id_E_RABs_DataForwardingAddress_List() { set(ignore); type=4;}
4673                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
4674                 template<typename V>  bool decode(V& v)
4675                 {
4676                         clear();
4677                         if(!v(ref_nested())) return false;
4678                         if(equal(ignore)) { type = 1; return true; }
4679                         else if(equal(ignore)) { type = 2; return true; }
4680                         else if(equal(ignore)) { type = 3; return true; }
4681                         else if(equal(ignore)) { type = 4; return true; }
4682                         else { type = 5; return true;}
4683                         return false;
4684
4685                 }
4686                 template<typename V> bool encode(V& v) const
4687                 {
4688                         return v(ref_nested());
4689
4690                 }
4691                 protected:
4692                 template<typename V>  bool decode(size_t index, V& v)
4693                 {
4694                         clear();
4695                         switch(index)
4696                         {
4697                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
4698                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
4699                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
4700                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
4701                         case 5: type = 5; return v(ref_nested());
4702                         ref_nested().clear();
4703                         }
4704                         return false;
4705
4706                 }
4707                 template<typename V> bool encode(size_t index, V& v) const
4708                 {
4709                         if(index != type) {return false;} return v(ref_nested());
4710
4711                 }
4712                 private:
4713                 size_t type {0};
4714
4715         };
4716         struct Value_t : asn::typefield<true>
4717         {
4718                 ~Value_t()      {clear();}
4719                 size_t get_index() const {return type;}
4720                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(1); }
4721                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(1); }
4722                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
4723                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
4724                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
4725                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
4726                 E_RABs_DataForwardingAddress_List& select_id_E_RABs_DataForwardingAddress_List() { return set<E_RABs_DataForwardingAddress_List>(4); }
4727                 E_RABs_DataForwardingAddress_List const* get_id_E_RABs_DataForwardingAddress_List() const { return get<E_RABs_DataForwardingAddress_List>(4); }
4728                 bool is_unknown() const { return type == 5; }
4729                 void clear()
4730                 {
4731                         switch(type)
4732                         {
4733                         case 1: var.destroy<UE_X2AP_ID_Extension>(); break;
4734                         case 2: var.destroy<UE_X2AP_ID>(); break;
4735                         case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
4736                         case 4: var.destroy<E_RABs_DataForwardingAddress_List>(); break;
4737                         }
4738                         type = 0; ref_nested().clear();
4739                 }
4740                 template<typename V> static inline void enumerate(V& v)
4741                 {
4742                         v.template operator()<UE_X2AP_ID_Extension>(1);
4743                         v.template operator()<UE_X2AP_ID>(2);
4744                         v.template operator()<UE_X2AP_ID_Extension>(3);
4745                         v.template operator()<E_RABs_DataForwardingAddress_List>(4);
4746
4747                 }
4748                 protected:
4749                 template<typename V> bool decode(size_t index, V& v)
4750                 {
4751                         clear();
4752                         switch(index)
4753                         {
4754                         case 1: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
4755                         case 2: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
4756                         case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
4757                         case 4: v(select_id_E_RABs_DataForwardingAddress_List()); return true;
4758                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
4759                         }
4760                         return false;
4761
4762                 }
4763                 template<typename V> bool encode(size_t index, V& v) const
4764                 {
4765                         if(index != type) return false;
4766                         switch(type)
4767                         {
4768                         case 1: v(var.as<UE_X2AP_ID_Extension>()); return true;
4769                         case 2: v(var.as<UE_X2AP_ID>()); return true;
4770                         case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
4771                         case 4: v(var.as<E_RABs_DataForwardingAddress_List>()); return true;
4772                         }
4773                         return false;
4774
4775                 }
4776                 private:
4777                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
4778                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
4779                 union union_type
4780                 {
4781                         char dummy1[sizeof(E_RABs_DataForwardingAddress_List)];
4782                         char dummy2[sizeof(UE_X2AP_ID)];
4783                         char dummy3[sizeof(UE_X2AP_ID_Extension)];
4784
4785                 };
4786                 asn::variant<sizeof(union_type)> var;
4787                 size_t type {0};
4788
4789         };
4790         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
4791         {
4792                 size_t get_index() const {return type;}
4793                 bool is_unknown() const { return type == 5; }
4794                 void clear() {type = 0;}
4795                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=1;}
4796                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
4797                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
4798                 void select_id_E_RABs_DataForwardingAddress_List() { set(mandatory); type=4;}
4799                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
4800                 template<typename V>  bool decode(V& v)
4801                 {
4802                         clear();
4803                         if(!v(ref_nested())) return false;
4804                         if(equal(optional)) { type = 1; return true; }
4805                         else if(equal(mandatory)) { type = 2; return true; }
4806                         else if(equal(optional)) { type = 3; return true; }
4807                         else if(equal(mandatory)) { type = 4; return true; }
4808                         else { type = 5; return true;}
4809                         return false;
4810
4811                 }
4812                 template<typename V> bool encode(V& v) const
4813                 {
4814                         return v(ref_nested());
4815
4816                 }
4817                 protected:
4818                 template<typename V>  bool decode(size_t index, V& v)
4819                 {
4820                         clear();
4821                         switch(index)
4822                         {
4823                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
4824                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
4825                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
4826                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
4827                         case 5: type = 5; return v(ref_nested());
4828                         ref_nested().clear();
4829                         }
4830                         return false;
4831
4832                 }
4833                 template<typename V> bool encode(size_t index, V& v) const
4834                 {
4835                         if(index != type) {return false;} return v(ref_nested());
4836
4837                 }
4838                 private:
4839                 size_t type {0};
4840
4841         };
4842
4843 };
4844 /*
4845 DataForwardingAddressIndication ::= SEQUENCE {
4846         protocolIEs             ProtocolIE-Container    {{DataForwardingAddressIndication-IEs}},
4847         ...
4848 }
4849 */
4850
4851 struct DataForwardingAddressIndication : asn::sequence<1, 0, true, 0>
4852 {
4853         static constexpr const char* name() {return "DataForwardingAddressIndication";}
4854         using parent_t = asn::sequence<1, 0, true, 0>;
4855         struct protocolIEs_t : ProtocolIE_Container<DataForwardingAddressIndication_IEs>
4856         {
4857                 static constexpr const char* name() {return "protocolIEs_t";}
4858                 using parent_t = ProtocolIE_Container<DataForwardingAddressIndication_IEs>;
4859
4860         };
4861         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
4862         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
4863         template<typename V> void decode(V& v)
4864         {
4865                 v(protocolIEs);
4866
4867         };
4868         template<typename V> void encode(V& v) const
4869         {
4870                 v(protocolIEs);
4871
4872         };
4873         void clear()
4874         {
4875                 protocolIEs.clear();
4876
4877         };
4878         private:
4879         protocolIEs_t   protocolIEs;
4880
4881 };
4882 /*
4883 E-RABs-Admitted-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4884         ...
4885 }
4886 */
4887
4888 struct E_RABs_Admitted_Item_ExtIEs
4889 {
4890         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4891         {
4892                 size_t get_index() const {return type;}
4893                 bool is_unknown() const { return type == 1; }
4894                 void clear() {type = 0;}
4895                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4896                 template<typename V>  bool decode(V& v)
4897                 {
4898                         clear();
4899                         if(!v(ref_nested())) return false;
4900                         { type = 1; return true;}
4901                         return false;
4902
4903                 }
4904                 template<typename V> bool encode(V& v) const
4905                 {
4906                         return v(ref_nested());
4907
4908                 }
4909                 protected:
4910                 template<typename V>  bool decode(size_t index, V& v)
4911                 {
4912                         clear();
4913                         switch(index)
4914                         {
4915                         case 1: type = 1; return v(ref_nested());
4916                         ref_nested().clear();
4917                         }
4918                         return false;
4919
4920                 }
4921                 template<typename V> bool encode(size_t index, V& v) const
4922                 {
4923                         if(index != type) {return false;} return v(ref_nested());
4924
4925                 }
4926                 private:
4927                 size_t type {0};
4928
4929         };
4930         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4931         {
4932                 size_t get_index() const {return type;}
4933                 bool is_unknown() const { return type == 1; }
4934                 void clear() {type = 0;}
4935                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4936                 template<typename V>  bool decode(V& v)
4937                 {
4938                         clear();
4939                         if(!v(ref_nested())) return false;
4940                         { type = 1; return true;}
4941                         return false;
4942
4943                 }
4944                 template<typename V> bool encode(V& v) const
4945                 {
4946                         return v(ref_nested());
4947
4948                 }
4949                 protected:
4950                 template<typename V>  bool decode(size_t index, V& v)
4951                 {
4952                         clear();
4953                         switch(index)
4954                         {
4955                         case 1: type = 1; return v(ref_nested());
4956                         ref_nested().clear();
4957                         }
4958                         return false;
4959
4960                 }
4961                 template<typename V> bool encode(size_t index, V& v) const
4962                 {
4963                         if(index != type) {return false;} return v(ref_nested());
4964
4965                 }
4966                 private:
4967                 size_t type {0};
4968
4969         };
4970         struct Extension_t : asn::typefield<true>
4971         {
4972                 ~Extension_t()  {clear();}
4973                 size_t get_index() const {return type;}
4974                 bool is_unknown() const { return type == 1; }
4975                 void clear()
4976                 {
4977                         type = 0; ref_nested().clear();
4978                 }
4979                 template<typename V> static inline void enumerate(V& v)
4980                 {
4981
4982                 }
4983                 protected:
4984                 template<typename V> bool decode(size_t index, V& v)
4985                 {
4986                         clear();
4987                         switch(index)
4988                         {
4989                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4990                         }
4991                         return false;
4992
4993                 }
4994                 template<typename V> bool encode(size_t index, V& v) const
4995                 {
4996                         if(index != type) return false;
4997                         return false;
4998
4999                 }
5000                 private:
5001                 size_t type {0};
5002
5003         };
5004         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5005         {
5006                 size_t get_index() const {return type;}
5007                 bool is_unknown() const { return type == 1; }
5008                 void clear() {type = 0;}
5009                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5010                 template<typename V>  bool decode(V& v)
5011                 {
5012                         clear();
5013                         if(!v(ref_nested())) return false;
5014                         { type = 1; return true;}
5015                         return false;
5016
5017                 }
5018                 template<typename V> bool encode(V& v) const
5019                 {
5020                         return v(ref_nested());
5021
5022                 }
5023                 protected:
5024                 template<typename V>  bool decode(size_t index, V& v)
5025                 {
5026                         clear();
5027                         switch(index)
5028                         {
5029                         case 1: type = 1; return v(ref_nested());
5030                         ref_nested().clear();
5031                         }
5032                         return false;
5033
5034                 }
5035                 template<typename V> bool encode(size_t index, V& v) const
5036                 {
5037                         if(index != type) {return false;} return v(ref_nested());
5038
5039                 }
5040                 private:
5041                 size_t type {0};
5042
5043         };
5044
5045 };
5046 /*
5047 E-RABs-Admitted-Item ::= SEQUENCE {
5048         e-RAB-ID                                        E-RAB-ID,
5049         uL-GTP-TunnelEndpoint                   GTPtunnelEndpoint       OPTIONAL,
5050         dL-GTP-TunnelEndpoint                   GTPtunnelEndpoint       OPTIONAL,
5051         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-Item-ExtIEs} }    OPTIONAL,
5052         ...
5053 }
5054 */
5055
5056 struct E_RABs_Admitted_Item : asn::sequence<4, 0, true, 3>
5057 {
5058         static constexpr const char* name() {return "E-RABs-Admitted-Item";}
5059         using parent_t = asn::sequence<4, 0, true, 3>;
5060         struct e_RAB_ID_t : E_RAB_ID
5061         {
5062                 static constexpr const char* name() {return "e_RAB_ID_t";}
5063                 using parent_t = E_RAB_ID;
5064
5065         };
5066         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5067         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5068         struct uL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
5069         {
5070                 static constexpr const char* name() {return "uL_GTP_TunnelEndpoint_t";}
5071                 using parent_t = GTPtunnelEndpoint;
5072                 static constexpr bool optional = true;
5073
5074         };
5075         uL_GTP_TunnelEndpoint_t& set_uL_GTP_TunnelEndpoint() { uL_GTP_TunnelEndpoint.setpresent(true); return uL_GTP_TunnelEndpoint;}
5076         uL_GTP_TunnelEndpoint_t const* get_uL_GTP_TunnelEndpoint() const {return uL_GTP_TunnelEndpoint.is_valid() ? &uL_GTP_TunnelEndpoint : nullptr;}
5077         struct dL_GTP_TunnelEndpoint_t : GTPtunnelEndpoint
5078         {
5079                 static constexpr const char* name() {return "dL_GTP_TunnelEndpoint_t";}
5080                 using parent_t = GTPtunnelEndpoint;
5081                 static constexpr bool optional = true;
5082
5083         };
5084         dL_GTP_TunnelEndpoint_t& set_dL_GTP_TunnelEndpoint() { dL_GTP_TunnelEndpoint.setpresent(true); return dL_GTP_TunnelEndpoint;}
5085         dL_GTP_TunnelEndpoint_t const* get_dL_GTP_TunnelEndpoint() const {return dL_GTP_TunnelEndpoint.is_valid() ? &dL_GTP_TunnelEndpoint : nullptr;}
5086         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_Item_ExtIEs>
5087         {
5088                 static constexpr const char* name() {return "iE_Extensions_t";}
5089                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_Item_ExtIEs>;
5090                 static constexpr bool optional = true;
5091
5092         };
5093         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5094         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5095         template<typename V> void decode(V& v)
5096         {
5097                 v(e_RAB_ID);
5098                 v(uL_GTP_TunnelEndpoint);
5099                 v(dL_GTP_TunnelEndpoint);
5100                 v(iE_Extensions);
5101
5102         };
5103         template<typename V> void encode(V& v) const
5104         {
5105                 v(e_RAB_ID);
5106                 v(uL_GTP_TunnelEndpoint);
5107                 v(dL_GTP_TunnelEndpoint);
5108                 v(iE_Extensions);
5109
5110         };
5111         void clear()
5112         {
5113                 e_RAB_ID.clear();
5114                 uL_GTP_TunnelEndpoint.clear();
5115                 dL_GTP_TunnelEndpoint.clear();
5116                 iE_Extensions.clear();
5117
5118         };
5119         private:
5120         e_RAB_ID_t      e_RAB_ID;
5121         uL_GTP_TunnelEndpoint_t uL_GTP_TunnelEndpoint;
5122         dL_GTP_TunnelEndpoint_t dL_GTP_TunnelEndpoint;
5123         iE_Extensions_t iE_Extensions;
5124
5125 };
5126 /*
5127 E-RABs-Admitted-ItemIEs X2AP-PROTOCOL-IES ::= {
5128         { ID id-E-RABs-Admitted-Item    CRITICALITY ignore      TYPE E-RABs-Admitted-Item       PRESENCE mandatory      }
5129 }
5130 */
5131
5132 struct E_RABs_Admitted_ItemIEs
5133 {
5134         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
5135         {
5136                 size_t get_index() const {return type;}
5137                 void clear() {type = 0;}
5138                 void select_id_E_RABs_Admitted_Item() { set(id_E_RABs_Admitted_Item); type=1;}
5139                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
5140                 template<typename V>  bool decode(V& v)
5141                 {
5142                         clear();
5143                         if(!v(ref_nested())) return false;
5144                         if(equal(id_E_RABs_Admitted_Item)) { type = 1; return true; }
5145                         return false;
5146
5147                 }
5148                 template<typename V> bool encode(V& v) const
5149                 {
5150                         return v(ref_nested());
5151
5152                 }
5153                 protected:
5154                 template<typename V>  bool decode(size_t index, V& v)
5155                 {
5156                         clear();
5157                         switch(index)
5158                         {
5159                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_Item);} return false;
5160                         ref_nested().clear();
5161                         }
5162                         return false;
5163
5164                 }
5165                 template<typename V> bool encode(size_t index, V& v) const
5166                 {
5167                         if(index != type) {return false;} return v(ref_nested());
5168
5169                 }
5170                 private:
5171                 size_t type {0};
5172
5173         };
5174         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
5175         {
5176                 size_t get_index() const {return type;}
5177                 void clear() {type = 0;}
5178                 void select_id_E_RABs_Admitted_Item() { set(ignore); type=1;}
5179                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
5180                 template<typename V>  bool decode(V& v)
5181                 {
5182                         clear();
5183                         if(!v(ref_nested())) return false;
5184                         if(equal(ignore)) { type = 1; return true; }
5185                         return false;
5186
5187                 }
5188                 template<typename V> bool encode(V& v) const
5189                 {
5190                         return v(ref_nested());
5191
5192                 }
5193                 protected:
5194                 template<typename V>  bool decode(size_t index, V& v)
5195                 {
5196                         clear();
5197                         switch(index)
5198                         {
5199                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
5200                         ref_nested().clear();
5201                         }
5202                         return false;
5203
5204                 }
5205                 template<typename V> bool encode(size_t index, V& v) const
5206                 {
5207                         if(index != type) {return false;} return v(ref_nested());
5208
5209                 }
5210                 private:
5211                 size_t type {0};
5212
5213         };
5214         struct Value_t : asn::typefield<false>
5215         {
5216                 ~Value_t()      {clear();}
5217                 size_t get_index() const {return type;}
5218                 E_RABs_Admitted_Item& select_id_E_RABs_Admitted_Item() { return set<E_RABs_Admitted_Item>(1); }
5219                 E_RABs_Admitted_Item const* get_id_E_RABs_Admitted_Item() const { return get<E_RABs_Admitted_Item>(1); }
5220                 void clear()
5221                 {
5222                         switch(type)
5223                         {
5224                         case 1: var.destroy<E_RABs_Admitted_Item>(); break;
5225                         }
5226                         type = 0; ref_nested().clear();
5227                 }
5228                 template<typename V> static inline void enumerate(V& v)
5229                 {
5230                         v.template operator()<E_RABs_Admitted_Item>(1);
5231
5232                 }
5233                 protected:
5234                 template<typename V> bool decode(size_t index, V& v)
5235                 {
5236                         clear();
5237                         switch(index)
5238                         {
5239                         case 1: v(select_id_E_RABs_Admitted_Item()); return true;
5240                         }
5241                         return false;
5242
5243                 }
5244                 template<typename V> bool encode(size_t index, V& v) const
5245                 {
5246                         if(index != type) return false;
5247                         switch(type)
5248                         {
5249                         case 1: v(var.as<E_RABs_Admitted_Item>()); return true;
5250                         }
5251                         return false;
5252
5253                 }
5254                 private:
5255                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
5256                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
5257                 union union_type
5258                 {
5259                         char dummy1[sizeof(E_RABs_Admitted_Item)];
5260
5261                 };
5262                 asn::variant<sizeof(union_type)> var;
5263                 size_t type {0};
5264
5265         };
5266         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
5267         {
5268                 size_t get_index() const {return type;}
5269                 void clear() {type = 0;}
5270                 void select_id_E_RABs_Admitted_Item() { set(mandatory); type=1;}
5271                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
5272                 template<typename V>  bool decode(V& v)
5273                 {
5274                         clear();
5275                         if(!v(ref_nested())) return false;
5276                         if(equal(mandatory)) { type = 1; return true; }
5277                         return false;
5278
5279                 }
5280                 template<typename V> bool encode(V& v) const
5281                 {
5282                         return v(ref_nested());
5283
5284                 }
5285                 protected:
5286                 template<typename V>  bool decode(size_t index, V& v)
5287                 {
5288                         clear();
5289                         switch(index)
5290                         {
5291                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
5292                         ref_nested().clear();
5293                         }
5294                         return false;
5295
5296                 }
5297                 template<typename V> bool encode(size_t index, V& v) const
5298                 {
5299                         if(index != type) {return false;} return v(ref_nested());
5300
5301                 }
5302                 private:
5303                 size_t type {0};
5304
5305         };
5306
5307 };
5308 /*
5309 E-RABs-Admitted-List            ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ItemIEs} }
5310 */
5311
5312 struct E_RABs_Admitted_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>
5313 {
5314         static constexpr const char* name() {return "E_RABs_Admitted_List_elm";}
5315         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ItemIEs>;
5316
5317 };
5318 struct E_RABs_Admitted_List : asn::sequenceof<E_RABs_Admitted_List_elm>
5319 {
5320         static constexpr const char* name() {return "E-RABs-Admitted-List";}
5321         using parent_t = asn::sequenceof<E_RABs_Admitted_List_elm>;
5322         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
5323
5324 };
5325 /*
5326 E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5327         ...
5328 }
5329 */
5330
5331 struct E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs
5332 {
5333         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5334         {
5335                 size_t get_index() const {return type;}
5336                 bool is_unknown() const { return type == 1; }
5337                 void clear() {type = 0;}
5338                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5339                 template<typename V>  bool decode(V& v)
5340                 {
5341                         clear();
5342                         if(!v(ref_nested())) return false;
5343                         { type = 1; return true;}
5344                         return false;
5345
5346                 }
5347                 template<typename V> bool encode(V& v) const
5348                 {
5349                         return v(ref_nested());
5350
5351                 }
5352                 protected:
5353                 template<typename V>  bool decode(size_t index, V& v)
5354                 {
5355                         clear();
5356                         switch(index)
5357                         {
5358                         case 1: type = 1; return v(ref_nested());
5359                         ref_nested().clear();
5360                         }
5361                         return false;
5362
5363                 }
5364                 template<typename V> bool encode(size_t index, V& v) const
5365                 {
5366                         if(index != type) {return false;} return v(ref_nested());
5367
5368                 }
5369                 private:
5370                 size_t type {0};
5371
5372         };
5373         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5374         {
5375                 size_t get_index() const {return type;}
5376                 bool is_unknown() const { return type == 1; }
5377                 void clear() {type = 0;}
5378                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5379                 template<typename V>  bool decode(V& v)
5380                 {
5381                         clear();
5382                         if(!v(ref_nested())) return false;
5383                         { type = 1; return true;}
5384                         return false;
5385
5386                 }
5387                 template<typename V> bool encode(V& v) const
5388                 {
5389                         return v(ref_nested());
5390
5391                 }
5392                 protected:
5393                 template<typename V>  bool decode(size_t index, V& v)
5394                 {
5395                         clear();
5396                         switch(index)
5397                         {
5398                         case 1: type = 1; return v(ref_nested());
5399                         ref_nested().clear();
5400                         }
5401                         return false;
5402
5403                 }
5404                 template<typename V> bool encode(size_t index, V& v) const
5405                 {
5406                         if(index != type) {return false;} return v(ref_nested());
5407
5408                 }
5409                 private:
5410                 size_t type {0};
5411
5412         };
5413         struct Extension_t : asn::typefield<true>
5414         {
5415                 ~Extension_t()  {clear();}
5416                 size_t get_index() const {return type;}
5417                 bool is_unknown() const { return type == 1; }
5418                 void clear()
5419                 {
5420                         type = 0; ref_nested().clear();
5421                 }
5422                 template<typename V> static inline void enumerate(V& v)
5423                 {
5424
5425                 }
5426                 protected:
5427                 template<typename V> bool decode(size_t index, V& v)
5428                 {
5429                         clear();
5430                         switch(index)
5431                         {
5432                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5433                         }
5434                         return false;
5435
5436                 }
5437                 template<typename V> bool encode(size_t index, V& v) const
5438                 {
5439                         if(index != type) return false;
5440                         return false;
5441
5442                 }
5443                 private:
5444                 size_t type {0};
5445
5446         };
5447         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5448         {
5449                 size_t get_index() const {return type;}
5450                 bool is_unknown() const { return type == 1; }
5451                 void clear() {type = 0;}
5452                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5453                 template<typename V>  bool decode(V& v)
5454                 {
5455                         clear();
5456                         if(!v(ref_nested())) return false;
5457                         { type = 1; return true;}
5458                         return false;
5459
5460                 }
5461                 template<typename V> bool encode(V& v) const
5462                 {
5463                         return v(ref_nested());
5464
5465                 }
5466                 protected:
5467                 template<typename V>  bool decode(size_t index, V& v)
5468                 {
5469                         clear();
5470                         switch(index)
5471                         {
5472                         case 1: type = 1; return v(ref_nested());
5473                         ref_nested().clear();
5474                         }
5475                         return false;
5476
5477                 }
5478                 template<typename V> bool encode(size_t index, V& v) const
5479                 {
5480                         if(index != type) {return false;} return v(ref_nested());
5481
5482                 }
5483                 private:
5484                 size_t type {0};
5485
5486         };
5487
5488 };
5489 /*
5490 E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
5491         e-RAB-ID                                                                E-RAB-ID,
5492         s1-DL-GTPtunnelEndpoint                                 GTPtunnelEndpoint,
5493         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
5494         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
5495         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-SCG-BearerExtIEs} }        OPTIONAL,
5496         ...
5497 }
5498 */
5499
5500 struct E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 3>
5501 {
5502         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer";}
5503         using parent_t = asn::sequence<5, 0, true, 3>;
5504         struct e_RAB_ID_t : E_RAB_ID
5505         {
5506                 static constexpr const char* name() {return "e_RAB_ID_t";}
5507                 using parent_t = E_RAB_ID;
5508
5509         };
5510         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5511         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5512         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5513         {
5514                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
5515                 using parent_t = GTPtunnelEndpoint;
5516
5517         };
5518         s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
5519         s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
5520         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5521         {
5522                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
5523                 using parent_t = GTPtunnelEndpoint;
5524                 static constexpr bool optional = true;
5525
5526         };
5527         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
5528         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
5529         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5530         {
5531                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
5532                 using parent_t = GTPtunnelEndpoint;
5533                 static constexpr bool optional = true;
5534
5535         };
5536         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
5537         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
5538         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>
5539         {
5540                 static constexpr const char* name() {return "iE_Extensions_t";}
5541                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_SCG_BearerExtIEs>;
5542                 static constexpr bool optional = true;
5543
5544         };
5545         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5546         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5547         template<typename V> void decode(V& v)
5548         {
5549                 v(e_RAB_ID);
5550                 v(s1_DL_GTPtunnelEndpoint);
5551                 v(dL_Forwarding_GTPtunnelEndpoint);
5552                 v(uL_Forwarding_GTPtunnelEndpoint);
5553                 v(iE_Extensions);
5554
5555         };
5556         template<typename V> void encode(V& v) const
5557         {
5558                 v(e_RAB_ID);
5559                 v(s1_DL_GTPtunnelEndpoint);
5560                 v(dL_Forwarding_GTPtunnelEndpoint);
5561                 v(uL_Forwarding_GTPtunnelEndpoint);
5562                 v(iE_Extensions);
5563
5564         };
5565         void clear()
5566         {
5567                 e_RAB_ID.clear();
5568                 s1_DL_GTPtunnelEndpoint.clear();
5569                 dL_Forwarding_GTPtunnelEndpoint.clear();
5570                 uL_Forwarding_GTPtunnelEndpoint.clear();
5571                 iE_Extensions.clear();
5572
5573         };
5574         private:
5575         e_RAB_ID_t      e_RAB_ID;
5576         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
5577         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
5578         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
5579         iE_Extensions_t iE_Extensions;
5580
5581 };
5582 /*
5583 E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5584         ...
5585 }
5586 */
5587
5588 struct E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs
5589 {
5590         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5591         {
5592                 size_t get_index() const {return type;}
5593                 bool is_unknown() const { return type == 1; }
5594                 void clear() {type = 0;}
5595                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5596                 template<typename V>  bool decode(V& v)
5597                 {
5598                         clear();
5599                         if(!v(ref_nested())) return false;
5600                         { type = 1; return true;}
5601                         return false;
5602
5603                 }
5604                 template<typename V> bool encode(V& v) const
5605                 {
5606                         return v(ref_nested());
5607
5608                 }
5609                 protected:
5610                 template<typename V>  bool decode(size_t index, V& v)
5611                 {
5612                         clear();
5613                         switch(index)
5614                         {
5615                         case 1: type = 1; return v(ref_nested());
5616                         ref_nested().clear();
5617                         }
5618                         return false;
5619
5620                 }
5621                 template<typename V> bool encode(size_t index, V& v) const
5622                 {
5623                         if(index != type) {return false;} return v(ref_nested());
5624
5625                 }
5626                 private:
5627                 size_t type {0};
5628
5629         };
5630         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5631         {
5632                 size_t get_index() const {return type;}
5633                 bool is_unknown() const { return type == 1; }
5634                 void clear() {type = 0;}
5635                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5636                 template<typename V>  bool decode(V& v)
5637                 {
5638                         clear();
5639                         if(!v(ref_nested())) return false;
5640                         { type = 1; return true;}
5641                         return false;
5642
5643                 }
5644                 template<typename V> bool encode(V& v) const
5645                 {
5646                         return v(ref_nested());
5647
5648                 }
5649                 protected:
5650                 template<typename V>  bool decode(size_t index, V& v)
5651                 {
5652                         clear();
5653                         switch(index)
5654                         {
5655                         case 1: type = 1; return v(ref_nested());
5656                         ref_nested().clear();
5657                         }
5658                         return false;
5659
5660                 }
5661                 template<typename V> bool encode(size_t index, V& v) const
5662                 {
5663                         if(index != type) {return false;} return v(ref_nested());
5664
5665                 }
5666                 private:
5667                 size_t type {0};
5668
5669         };
5670         struct Extension_t : asn::typefield<true>
5671         {
5672                 ~Extension_t()  {clear();}
5673                 size_t get_index() const {return type;}
5674                 bool is_unknown() const { return type == 1; }
5675                 void clear()
5676                 {
5677                         type = 0; ref_nested().clear();
5678                 }
5679                 template<typename V> static inline void enumerate(V& v)
5680                 {
5681
5682                 }
5683                 protected:
5684                 template<typename V> bool decode(size_t index, V& v)
5685                 {
5686                         clear();
5687                         switch(index)
5688                         {
5689                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5690                         }
5691                         return false;
5692
5693                 }
5694                 template<typename V> bool encode(size_t index, V& v) const
5695                 {
5696                         if(index != type) return false;
5697                         return false;
5698
5699                 }
5700                 private:
5701                 size_t type {0};
5702
5703         };
5704         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5705         {
5706                 size_t get_index() const {return type;}
5707                 bool is_unknown() const { return type == 1; }
5708                 void clear() {type = 0;}
5709                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5710                 template<typename V>  bool decode(V& v)
5711                 {
5712                         clear();
5713                         if(!v(ref_nested())) return false;
5714                         { type = 1; return true;}
5715                         return false;
5716
5717                 }
5718                 template<typename V> bool encode(V& v) const
5719                 {
5720                         return v(ref_nested());
5721
5722                 }
5723                 protected:
5724                 template<typename V>  bool decode(size_t index, V& v)
5725                 {
5726                         clear();
5727                         switch(index)
5728                         {
5729                         case 1: type = 1; return v(ref_nested());
5730                         ref_nested().clear();
5731                         }
5732                         return false;
5733
5734                 }
5735                 template<typename V> bool encode(size_t index, V& v) const
5736                 {
5737                         if(index != type) {return false;} return v(ref_nested());
5738
5739                 }
5740                 private:
5741                 size_t type {0};
5742
5743         };
5744
5745 };
5746 /*
5747 E-RABs-Admitted-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
5748         e-RAB-ID                                                E-RAB-ID,
5749         seNB-GTPtunnelEndpoint                  GTPtunnelEndpoint,
5750         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
5751         ...
5752 }
5753 */
5754
5755 struct E_RABs_Admitted_ToBeAdded_Item_Split_Bearer : asn::sequence<3, 0, true, 1>
5756 {
5757         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item-Split-Bearer";}
5758         using parent_t = asn::sequence<3, 0, true, 1>;
5759         struct e_RAB_ID_t : E_RAB_ID
5760         {
5761                 static constexpr const char* name() {return "e_RAB_ID_t";}
5762                 using parent_t = E_RAB_ID;
5763
5764         };
5765         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
5766         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
5767         struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
5768         {
5769                 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
5770                 using parent_t = GTPtunnelEndpoint;
5771
5772         };
5773         seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
5774         seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
5775         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>
5776         {
5777                 static constexpr const char* name() {return "iE_Extensions_t";}
5778                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_Item_Split_BearerExtIEs>;
5779                 static constexpr bool optional = true;
5780
5781         };
5782         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5783         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5784         template<typename V> void decode(V& v)
5785         {
5786                 v(e_RAB_ID);
5787                 v(seNB_GTPtunnelEndpoint);
5788                 v(iE_Extensions);
5789
5790         };
5791         template<typename V> void encode(V& v) const
5792         {
5793                 v(e_RAB_ID);
5794                 v(seNB_GTPtunnelEndpoint);
5795                 v(iE_Extensions);
5796
5797         };
5798         void clear()
5799         {
5800                 e_RAB_ID.clear();
5801                 seNB_GTPtunnelEndpoint.clear();
5802                 iE_Extensions.clear();
5803
5804         };
5805         private:
5806         e_RAB_ID_t      e_RAB_ID;
5807         seNB_GTPtunnelEndpoint_t        seNB_GTPtunnelEndpoint;
5808         iE_Extensions_t iE_Extensions;
5809
5810 };
5811 /*
5812 E-RABs-Admitted-ToBeAdded-Item ::= CHOICE {
5813         sCG-Bearer              E-RABs-Admitted-ToBeAdded-Item-SCG-Bearer,
5814         split-Bearer    E-RABs-Admitted-ToBeAdded-Item-Split-Bearer,
5815         ...
5816 }
5817 */
5818
5819 struct E_RABs_Admitted_ToBeAdded_Item : asn::choice<2, 0, true>
5820 {
5821         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-Item";}
5822         using parent_t = asn::choice<2, 0, true>;
5823         index_type get_index() const {return index;}
5824         bool is_unknown() const {return index == 3;}
5825         void set_unknown() { set_index(3);  }
5826         ~E_RABs_Admitted_ToBeAdded_Item() {clear();}
5827         struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer
5828         {
5829                 static constexpr const char* name() {return "sCG_Bearer_t";}
5830                 using parent_t = E_RABs_Admitted_ToBeAdded_Item_SCG_Bearer;
5831
5832         };
5833         struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_Item_Split_Bearer
5834         {
5835                 static constexpr const char* name() {return "split_Bearer_t";}
5836                 using parent_t = E_RABs_Admitted_ToBeAdded_Item_Split_Bearer;
5837
5838         };
5839         void clear()
5840         {
5841                 switch(get_index())
5842                 {
5843                 case 1: var.destroy<sCG_Bearer_t>(); break;
5844                 case 2: var.destroy<split_Bearer_t>(); break;
5845                 }
5846                 index = 0;
5847                 base::clear();
5848         }
5849         template<typename V> bool decode(size_t idx, V& v)
5850         {
5851                 clear();
5852                 switch(idx)
5853                 {
5854                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
5855                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
5856                 }
5857                 return false;
5858
5859         }
5860         template<typename V> bool encode(V& v) const
5861         {
5862                 switch(get_index())
5863                 {
5864                 case 1: return v(var.as<sCG_Bearer_t>());
5865                 case 2: return v(var.as<split_Bearer_t>());
5866                 }
5867                 return false;
5868         }
5869         template<typename V> static inline void enumerate(V& v)
5870         {
5871                 v.template operator()<sCG_Bearer_t>(1);
5872                 v.template operator()<split_Bearer_t>(2);
5873
5874         }
5875         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
5876         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
5877         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
5878         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
5879         private:
5880         void set_index(index_type i) {index = i; base::set();}
5881         union union_type
5882         {
5883                 char dummy1[sizeof(sCG_Bearer_t)];
5884                 char dummy2[sizeof(split_Bearer_t)];
5885
5886         };
5887         asn::variant<sizeof(union_type)>        var;
5888         index_type      index {0};
5889 };
5890 /*
5891 E-RABs-Admitted-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
5892         { ID id-E-RABs-Admitted-ToBeAdded-Item  CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-Item             PRESENCE mandatory}
5893 }
5894 */
5895
5896 struct E_RABs_Admitted_ToBeAdded_ItemIEs
5897 {
5898         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
5899         {
5900                 size_t get_index() const {return type;}
5901                 void clear() {type = 0;}
5902                 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(id_E_RABs_Admitted_ToBeAdded_Item); type=1;}
5903                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
5904                 template<typename V>  bool decode(V& v)
5905                 {
5906                         clear();
5907                         if(!v(ref_nested())) return false;
5908                         if(equal(id_E_RABs_Admitted_ToBeAdded_Item)) { type = 1; return true; }
5909                         return false;
5910
5911                 }
5912                 template<typename V> bool encode(V& v) const
5913                 {
5914                         return v(ref_nested());
5915
5916                 }
5917                 protected:
5918                 template<typename V>  bool decode(size_t index, V& v)
5919                 {
5920                         clear();
5921                         switch(index)
5922                         {
5923                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_Item);} return false;
5924                         ref_nested().clear();
5925                         }
5926                         return false;
5927
5928                 }
5929                 template<typename V> bool encode(size_t index, V& v) const
5930                 {
5931                         if(index != type) {return false;} return v(ref_nested());
5932
5933                 }
5934                 private:
5935                 size_t type {0};
5936
5937         };
5938         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
5939         {
5940                 size_t get_index() const {return type;}
5941                 void clear() {type = 0;}
5942                 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(ignore); type=1;}
5943                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
5944                 template<typename V>  bool decode(V& v)
5945                 {
5946                         clear();
5947                         if(!v(ref_nested())) return false;
5948                         if(equal(ignore)) { type = 1; return true; }
5949                         return false;
5950
5951                 }
5952                 template<typename V> bool encode(V& v) const
5953                 {
5954                         return v(ref_nested());
5955
5956                 }
5957                 protected:
5958                 template<typename V>  bool decode(size_t index, V& v)
5959                 {
5960                         clear();
5961                         switch(index)
5962                         {
5963                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
5964                         ref_nested().clear();
5965                         }
5966                         return false;
5967
5968                 }
5969                 template<typename V> bool encode(size_t index, V& v) const
5970                 {
5971                         if(index != type) {return false;} return v(ref_nested());
5972
5973                 }
5974                 private:
5975                 size_t type {0};
5976
5977         };
5978         struct Value_t : asn::typefield<false>
5979         {
5980                 ~Value_t()      {clear();}
5981                 size_t get_index() const {return type;}
5982                 E_RABs_Admitted_ToBeAdded_Item& select_id_E_RABs_Admitted_ToBeAdded_Item() { return set<E_RABs_Admitted_ToBeAdded_Item>(1); }
5983                 E_RABs_Admitted_ToBeAdded_Item const* get_id_E_RABs_Admitted_ToBeAdded_Item() const { return get<E_RABs_Admitted_ToBeAdded_Item>(1); }
5984                 void clear()
5985                 {
5986                         switch(type)
5987                         {
5988                         case 1: var.destroy<E_RABs_Admitted_ToBeAdded_Item>(); break;
5989                         }
5990                         type = 0; ref_nested().clear();
5991                 }
5992                 template<typename V> static inline void enumerate(V& v)
5993                 {
5994                         v.template operator()<E_RABs_Admitted_ToBeAdded_Item>(1);
5995
5996                 }
5997                 protected:
5998                 template<typename V> bool decode(size_t index, V& v)
5999                 {
6000                         clear();
6001                         switch(index)
6002                         {
6003                         case 1: v(select_id_E_RABs_Admitted_ToBeAdded_Item()); return true;
6004                         }
6005                         return false;
6006
6007                 }
6008                 template<typename V> bool encode(size_t index, V& v) const
6009                 {
6010                         if(index != type) return false;
6011                         switch(type)
6012                         {
6013                         case 1: v(var.as<E_RABs_Admitted_ToBeAdded_Item>()); return true;
6014                         }
6015                         return false;
6016
6017                 }
6018                 private:
6019                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
6020                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
6021                 union union_type
6022                 {
6023                         char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_Item)];
6024
6025                 };
6026                 asn::variant<sizeof(union_type)> var;
6027                 size_t type {0};
6028
6029         };
6030         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
6031         {
6032                 size_t get_index() const {return type;}
6033                 void clear() {type = 0;}
6034                 void select_id_E_RABs_Admitted_ToBeAdded_Item() { set(mandatory); type=1;}
6035                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
6036                 template<typename V>  bool decode(V& v)
6037                 {
6038                         clear();
6039                         if(!v(ref_nested())) return false;
6040                         if(equal(mandatory)) { type = 1; return true; }
6041                         return false;
6042
6043                 }
6044                 template<typename V> bool encode(V& v) const
6045                 {
6046                         return v(ref_nested());
6047
6048                 }
6049                 protected:
6050                 template<typename V>  bool decode(size_t index, V& v)
6051                 {
6052                         clear();
6053                         switch(index)
6054                         {
6055                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
6056                         ref_nested().clear();
6057                         }
6058                         return false;
6059
6060                 }
6061                 template<typename V> bool encode(size_t index, V& v) const
6062                 {
6063                         if(index != type) {return false;} return v(ref_nested());
6064
6065                 }
6066                 private:
6067                 size_t type {0};
6068
6069         };
6070
6071 };
6072 /*
6073 E-RABs-Admitted-ToBeAdded-List ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ItemIEs} }
6074 */
6075
6076 struct E_RABs_Admitted_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>
6077 {
6078         static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_List_elm";}
6079         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ItemIEs>;
6080
6081 };
6082 struct E_RABs_Admitted_ToBeAdded_List : asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>
6083 {
6084         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-List";}
6085         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_List_elm>;
6086         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
6087
6088 };
6089 /*
6090 E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6091         ...
6092 }
6093 */
6094
6095 struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs
6096 {
6097         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6098         {
6099                 size_t get_index() const {return type;}
6100                 bool is_unknown() const { return type == 1; }
6101                 void clear() {type = 0;}
6102                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6103                 template<typename V>  bool decode(V& v)
6104                 {
6105                         clear();
6106                         if(!v(ref_nested())) return false;
6107                         { type = 1; return true;}
6108                         return false;
6109
6110                 }
6111                 template<typename V> bool encode(V& v) const
6112                 {
6113                         return v(ref_nested());
6114
6115                 }
6116                 protected:
6117                 template<typename V>  bool decode(size_t index, V& v)
6118                 {
6119                         clear();
6120                         switch(index)
6121                         {
6122                         case 1: type = 1; return v(ref_nested());
6123                         ref_nested().clear();
6124                         }
6125                         return false;
6126
6127                 }
6128                 template<typename V> bool encode(size_t index, V& v) const
6129                 {
6130                         if(index != type) {return false;} return v(ref_nested());
6131
6132                 }
6133                 private:
6134                 size_t type {0};
6135
6136         };
6137         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6138         {
6139                 size_t get_index() const {return type;}
6140                 bool is_unknown() const { return type == 1; }
6141                 void clear() {type = 0;}
6142                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6143                 template<typename V>  bool decode(V& v)
6144                 {
6145                         clear();
6146                         if(!v(ref_nested())) return false;
6147                         { type = 1; return true;}
6148                         return false;
6149
6150                 }
6151                 template<typename V> bool encode(V& v) const
6152                 {
6153                         return v(ref_nested());
6154
6155                 }
6156                 protected:
6157                 template<typename V>  bool decode(size_t index, V& v)
6158                 {
6159                         clear();
6160                         switch(index)
6161                         {
6162                         case 1: type = 1; return v(ref_nested());
6163                         ref_nested().clear();
6164                         }
6165                         return false;
6166
6167                 }
6168                 template<typename V> bool encode(size_t index, V& v) const
6169                 {
6170                         if(index != type) {return false;} return v(ref_nested());
6171
6172                 }
6173                 private:
6174                 size_t type {0};
6175
6176         };
6177         struct Extension_t : asn::typefield<true>
6178         {
6179                 ~Extension_t()  {clear();}
6180                 size_t get_index() const {return type;}
6181                 bool is_unknown() const { return type == 1; }
6182                 void clear()
6183                 {
6184                         type = 0; ref_nested().clear();
6185                 }
6186                 template<typename V> static inline void enumerate(V& v)
6187                 {
6188
6189                 }
6190                 protected:
6191                 template<typename V> bool decode(size_t index, V& v)
6192                 {
6193                         clear();
6194                         switch(index)
6195                         {
6196                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6197                         }
6198                         return false;
6199
6200                 }
6201                 template<typename V> bool encode(size_t index, V& v) const
6202                 {
6203                         if(index != type) return false;
6204                         return false;
6205
6206                 }
6207                 private:
6208                 size_t type {0};
6209
6210         };
6211         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6212         {
6213                 size_t get_index() const {return type;}
6214                 bool is_unknown() const { return type == 1; }
6215                 void clear() {type = 0;}
6216                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6217                 template<typename V>  bool decode(V& v)
6218                 {
6219                         clear();
6220                         if(!v(ref_nested())) return false;
6221                         { type = 1; return true;}
6222                         return false;
6223
6224                 }
6225                 template<typename V> bool encode(V& v) const
6226                 {
6227                         return v(ref_nested());
6228
6229                 }
6230                 protected:
6231                 template<typename V>  bool decode(size_t index, V& v)
6232                 {
6233                         clear();
6234                         switch(index)
6235                         {
6236                         case 1: type = 1; return v(ref_nested());
6237                         ref_nested().clear();
6238                         }
6239                         return false;
6240
6241                 }
6242                 template<typename V> bool encode(size_t index, V& v) const
6243                 {
6244                         if(index != type) {return false;} return v(ref_nested());
6245
6246                 }
6247                 private:
6248                 size_t type {0};
6249
6250         };
6251
6252 };
6253 /*
6254 E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer ::= SEQUENCE {
6255         e-RAB-ID                                                                E-RAB-ID,
6256         s1-DL-GTPtunnelEndpoint                                 GTPtunnelEndpoint,
6257         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
6258         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
6259         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-BearerExtIEs} }  OPTIONAL,
6260         ...
6261 }
6262 */
6263
6264 struct E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer : asn::sequence<5, 0, true, 3>
6265 {
6266         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer";}
6267         using parent_t = asn::sequence<5, 0, true, 3>;
6268         struct e_RAB_ID_t : E_RAB_ID
6269         {
6270                 static constexpr const char* name() {return "e_RAB_ID_t";}
6271                 using parent_t = E_RAB_ID;
6272
6273         };
6274         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
6275         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
6276         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6277         {
6278                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
6279                 using parent_t = GTPtunnelEndpoint;
6280
6281         };
6282         s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
6283         s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
6284         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6285         {
6286                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
6287                 using parent_t = GTPtunnelEndpoint;
6288                 static constexpr bool optional = true;
6289
6290         };
6291         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
6292         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
6293         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6294         {
6295                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
6296                 using parent_t = GTPtunnelEndpoint;
6297                 static constexpr bool optional = true;
6298
6299         };
6300         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
6301         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
6302         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>
6303         {
6304                 static constexpr const char* name() {return "iE_Extensions_t";}
6305                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_BearerExtIEs>;
6306                 static constexpr bool optional = true;
6307
6308         };
6309         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6310         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6311         template<typename V> void decode(V& v)
6312         {
6313                 v(e_RAB_ID);
6314                 v(s1_DL_GTPtunnelEndpoint);
6315                 v(dL_Forwarding_GTPtunnelEndpoint);
6316                 v(uL_Forwarding_GTPtunnelEndpoint);
6317                 v(iE_Extensions);
6318
6319         };
6320         template<typename V> void encode(V& v) const
6321         {
6322                 v(e_RAB_ID);
6323                 v(s1_DL_GTPtunnelEndpoint);
6324                 v(dL_Forwarding_GTPtunnelEndpoint);
6325                 v(uL_Forwarding_GTPtunnelEndpoint);
6326                 v(iE_Extensions);
6327
6328         };
6329         void clear()
6330         {
6331                 e_RAB_ID.clear();
6332                 s1_DL_GTPtunnelEndpoint.clear();
6333                 dL_Forwarding_GTPtunnelEndpoint.clear();
6334                 uL_Forwarding_GTPtunnelEndpoint.clear();
6335                 iE_Extensions.clear();
6336
6337         };
6338         private:
6339         e_RAB_ID_t      e_RAB_ID;
6340         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
6341         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
6342         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
6343         iE_Extensions_t iE_Extensions;
6344
6345 };
6346 /*
6347 E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6348         ...
6349 }
6350 */
6351
6352 struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs
6353 {
6354         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6355         {
6356                 size_t get_index() const {return type;}
6357                 bool is_unknown() const { return type == 1; }
6358                 void clear() {type = 0;}
6359                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6360                 template<typename V>  bool decode(V& v)
6361                 {
6362                         clear();
6363                         if(!v(ref_nested())) return false;
6364                         { type = 1; return true;}
6365                         return false;
6366
6367                 }
6368                 template<typename V> bool encode(V& v) const
6369                 {
6370                         return v(ref_nested());
6371
6372                 }
6373                 protected:
6374                 template<typename V>  bool decode(size_t index, V& v)
6375                 {
6376                         clear();
6377                         switch(index)
6378                         {
6379                         case 1: type = 1; return v(ref_nested());
6380                         ref_nested().clear();
6381                         }
6382                         return false;
6383
6384                 }
6385                 template<typename V> bool encode(size_t index, V& v) const
6386                 {
6387                         if(index != type) {return false;} return v(ref_nested());
6388
6389                 }
6390                 private:
6391                 size_t type {0};
6392
6393         };
6394         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6395         {
6396                 size_t get_index() const {return type;}
6397                 bool is_unknown() const { return type == 1; }
6398                 void clear() {type = 0;}
6399                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6400                 template<typename V>  bool decode(V& v)
6401                 {
6402                         clear();
6403                         if(!v(ref_nested())) return false;
6404                         { type = 1; return true;}
6405                         return false;
6406
6407                 }
6408                 template<typename V> bool encode(V& v) const
6409                 {
6410                         return v(ref_nested());
6411
6412                 }
6413                 protected:
6414                 template<typename V>  bool decode(size_t index, V& v)
6415                 {
6416                         clear();
6417                         switch(index)
6418                         {
6419                         case 1: type = 1; return v(ref_nested());
6420                         ref_nested().clear();
6421                         }
6422                         return false;
6423
6424                 }
6425                 template<typename V> bool encode(size_t index, V& v) const
6426                 {
6427                         if(index != type) {return false;} return v(ref_nested());
6428
6429                 }
6430                 private:
6431                 size_t type {0};
6432
6433         };
6434         struct Extension_t : asn::typefield<true>
6435         {
6436                 ~Extension_t()  {clear();}
6437                 size_t get_index() const {return type;}
6438                 bool is_unknown() const { return type == 1; }
6439                 void clear()
6440                 {
6441                         type = 0; ref_nested().clear();
6442                 }
6443                 template<typename V> static inline void enumerate(V& v)
6444                 {
6445
6446                 }
6447                 protected:
6448                 template<typename V> bool decode(size_t index, V& v)
6449                 {
6450                         clear();
6451                         switch(index)
6452                         {
6453                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6454                         }
6455                         return false;
6456
6457                 }
6458                 template<typename V> bool encode(size_t index, V& v) const
6459                 {
6460                         if(index != type) return false;
6461                         return false;
6462
6463                 }
6464                 private:
6465                 size_t type {0};
6466
6467         };
6468         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6469         {
6470                 size_t get_index() const {return type;}
6471                 bool is_unknown() const { return type == 1; }
6472                 void clear() {type = 0;}
6473                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6474                 template<typename V>  bool decode(V& v)
6475                 {
6476                         clear();
6477                         if(!v(ref_nested())) return false;
6478                         { type = 1; return true;}
6479                         return false;
6480
6481                 }
6482                 template<typename V> bool encode(V& v) const
6483                 {
6484                         return v(ref_nested());
6485
6486                 }
6487                 protected:
6488                 template<typename V>  bool decode(size_t index, V& v)
6489                 {
6490                         clear();
6491                         switch(index)
6492                         {
6493                         case 1: type = 1; return v(ref_nested());
6494                         ref_nested().clear();
6495                         }
6496                         return false;
6497
6498                 }
6499                 template<typename V> bool encode(size_t index, V& v) const
6500                 {
6501                         if(index != type) {return false;} return v(ref_nested());
6502
6503                 }
6504                 private:
6505                 size_t type {0};
6506
6507         };
6508
6509 };
6510 /*
6511 E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer ::= SEQUENCE {
6512         e-RAB-ID                                                E-RAB-ID,
6513         seNB-GTPtunnelEndpoint                  GTPtunnelEndpoint,
6514         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
6515         ...
6516 }
6517 */
6518
6519 struct E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 1>
6520 {
6521         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer";}
6522         using parent_t = asn::sequence<3, 0, true, 1>;
6523         struct e_RAB_ID_t : E_RAB_ID
6524         {
6525                 static constexpr const char* name() {return "e_RAB_ID_t";}
6526                 using parent_t = E_RAB_ID;
6527
6528         };
6529         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
6530         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
6531         struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
6532         {
6533                 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
6534                 using parent_t = GTPtunnelEndpoint;
6535
6536         };
6537         seNB_GTPtunnelEndpoint_t& ref_seNB_GTPtunnelEndpoint() {return seNB_GTPtunnelEndpoint;}
6538         seNB_GTPtunnelEndpoint_t const& ref_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint;}
6539         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>
6540         {
6541                 static constexpr const char* name() {return "iE_Extensions_t";}
6542                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_ModAckItem_Split_BearerExtIEs>;
6543                 static constexpr bool optional = true;
6544
6545         };
6546         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6547         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6548         template<typename V> void decode(V& v)
6549         {
6550                 v(e_RAB_ID);
6551                 v(seNB_GTPtunnelEndpoint);
6552                 v(iE_Extensions);
6553
6554         };
6555         template<typename V> void encode(V& v) const
6556         {
6557                 v(e_RAB_ID);
6558                 v(seNB_GTPtunnelEndpoint);
6559                 v(iE_Extensions);
6560
6561         };
6562         void clear()
6563         {
6564                 e_RAB_ID.clear();
6565                 seNB_GTPtunnelEndpoint.clear();
6566                 iE_Extensions.clear();
6567
6568         };
6569         private:
6570         e_RAB_ID_t      e_RAB_ID;
6571         seNB_GTPtunnelEndpoint_t        seNB_GTPtunnelEndpoint;
6572         iE_Extensions_t iE_Extensions;
6573
6574 };
6575 /*
6576 E-RABs-Admitted-ToBeAdded-ModAckItem ::= CHOICE {
6577         sCG-Bearer              E-RABs-Admitted-ToBeAdded-ModAckItem-SCG-Bearer,
6578         split-Bearer    E-RABs-Admitted-ToBeAdded-ModAckItem-Split-Bearer,
6579         ...
6580 }
6581 */
6582
6583 struct E_RABs_Admitted_ToBeAdded_ModAckItem : asn::choice<2, 0, true>
6584 {
6585         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckItem";}
6586         using parent_t = asn::choice<2, 0, true>;
6587         index_type get_index() const {return index;}
6588         bool is_unknown() const {return index == 3;}
6589         void set_unknown() { set_index(3);  }
6590         ~E_RABs_Admitted_ToBeAdded_ModAckItem() {clear();}
6591         struct sCG_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer
6592         {
6593                 static constexpr const char* name() {return "sCG_Bearer_t";}
6594                 using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_SCG_Bearer;
6595
6596         };
6597         struct split_Bearer_t : E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer
6598         {
6599                 static constexpr const char* name() {return "split_Bearer_t";}
6600                 using parent_t = E_RABs_Admitted_ToBeAdded_ModAckItem_Split_Bearer;
6601
6602         };
6603         void clear()
6604         {
6605                 switch(get_index())
6606                 {
6607                 case 1: var.destroy<sCG_Bearer_t>(); break;
6608                 case 2: var.destroy<split_Bearer_t>(); break;
6609                 }
6610                 index = 0;
6611                 base::clear();
6612         }
6613         template<typename V> bool decode(size_t idx, V& v)
6614         {
6615                 clear();
6616                 switch(idx)
6617                 {
6618                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
6619                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
6620                 }
6621                 return false;
6622
6623         }
6624         template<typename V> bool encode(V& v) const
6625         {
6626                 switch(get_index())
6627                 {
6628                 case 1: return v(var.as<sCG_Bearer_t>());
6629                 case 2: return v(var.as<split_Bearer_t>());
6630                 }
6631                 return false;
6632         }
6633         template<typename V> static inline void enumerate(V& v)
6634         {
6635                 v.template operator()<sCG_Bearer_t>(1);
6636                 v.template operator()<split_Bearer_t>(2);
6637
6638         }
6639         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
6640         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
6641         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
6642         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
6643         private:
6644         void set_index(index_type i) {index = i; base::set();}
6645         union union_type
6646         {
6647                 char dummy1[sizeof(sCG_Bearer_t)];
6648                 char dummy2[sizeof(split_Bearer_t)];
6649
6650         };
6651         asn::variant<sizeof(union_type)>        var;
6652         index_type      index {0};
6653 };
6654 /*
6655 E-RABs-Admitted-ToBeAdded-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
6656         { ID id-E-RABs-Admitted-ToBeAdded-ModAckItem    CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-ModAckItem               PRESENCE mandatory}
6657 }
6658 */
6659
6660 struct E_RABs_Admitted_ToBeAdded_ModAckItemIEs
6661 {
6662         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
6663         {
6664                 size_t get_index() const {return type;}
6665                 void clear() {type = 0;}
6666                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(id_E_RABs_Admitted_ToBeAdded_ModAckItem); type=1;}
6667                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
6668                 template<typename V>  bool decode(V& v)
6669                 {
6670                         clear();
6671                         if(!v(ref_nested())) return false;
6672                         if(equal(id_E_RABs_Admitted_ToBeAdded_ModAckItem)) { type = 1; return true; }
6673                         return false;
6674
6675                 }
6676                 template<typename V> bool encode(V& v) const
6677                 {
6678                         return v(ref_nested());
6679
6680                 }
6681                 protected:
6682                 template<typename V>  bool decode(size_t index, V& v)
6683                 {
6684                         clear();
6685                         switch(index)
6686                         {
6687                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_ModAckItem);} return false;
6688                         ref_nested().clear();
6689                         }
6690                         return false;
6691
6692                 }
6693                 template<typename V> bool encode(size_t index, V& v) const
6694                 {
6695                         if(index != type) {return false;} return v(ref_nested());
6696
6697                 }
6698                 private:
6699                 size_t type {0};
6700
6701         };
6702         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
6703         {
6704                 size_t get_index() const {return type;}
6705                 void clear() {type = 0;}
6706                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(ignore); type=1;}
6707                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
6708                 template<typename V>  bool decode(V& v)
6709                 {
6710                         clear();
6711                         if(!v(ref_nested())) return false;
6712                         if(equal(ignore)) { type = 1; return true; }
6713                         return false;
6714
6715                 }
6716                 template<typename V> bool encode(V& v) const
6717                 {
6718                         return v(ref_nested());
6719
6720                 }
6721                 protected:
6722                 template<typename V>  bool decode(size_t index, V& v)
6723                 {
6724                         clear();
6725                         switch(index)
6726                         {
6727                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
6728                         ref_nested().clear();
6729                         }
6730                         return false;
6731
6732                 }
6733                 template<typename V> bool encode(size_t index, V& v) const
6734                 {
6735                         if(index != type) {return false;} return v(ref_nested());
6736
6737                 }
6738                 private:
6739                 size_t type {0};
6740
6741         };
6742         struct Value_t : asn::typefield<false>
6743         {
6744                 ~Value_t()      {clear();}
6745                 size_t get_index() const {return type;}
6746                 E_RABs_Admitted_ToBeAdded_ModAckItem& select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { return set<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
6747                 E_RABs_Admitted_ToBeAdded_ModAckItem const* get_id_E_RABs_Admitted_ToBeAdded_ModAckItem() const { return get<E_RABs_Admitted_ToBeAdded_ModAckItem>(1); }
6748                 void clear()
6749                 {
6750                         switch(type)
6751                         {
6752                         case 1: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckItem>(); break;
6753                         }
6754                         type = 0; ref_nested().clear();
6755                 }
6756                 template<typename V> static inline void enumerate(V& v)
6757                 {
6758                         v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckItem>(1);
6759
6760                 }
6761                 protected:
6762                 template<typename V> bool decode(size_t index, V& v)
6763                 {
6764                         clear();
6765                         switch(index)
6766                         {
6767                         case 1: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckItem()); return true;
6768                         }
6769                         return false;
6770
6771                 }
6772                 template<typename V> bool encode(size_t index, V& v) const
6773                 {
6774                         if(index != type) return false;
6775                         switch(type)
6776                         {
6777                         case 1: v(var.as<E_RABs_Admitted_ToBeAdded_ModAckItem>()); return true;
6778                         }
6779                         return false;
6780
6781                 }
6782                 private:
6783                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
6784                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
6785                 union union_type
6786                 {
6787                         char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_ModAckItem)];
6788
6789                 };
6790                 asn::variant<sizeof(union_type)> var;
6791                 size_t type {0};
6792
6793         };
6794         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
6795         {
6796                 size_t get_index() const {return type;}
6797                 void clear() {type = 0;}
6798                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckItem() { set(mandatory); type=1;}
6799                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
6800                 template<typename V>  bool decode(V& v)
6801                 {
6802                         clear();
6803                         if(!v(ref_nested())) return false;
6804                         if(equal(mandatory)) { type = 1; return true; }
6805                         return false;
6806
6807                 }
6808                 template<typename V> bool encode(V& v) const
6809                 {
6810                         return v(ref_nested());
6811
6812                 }
6813                 protected:
6814                 template<typename V>  bool decode(size_t index, V& v)
6815                 {
6816                         clear();
6817                         switch(index)
6818                         {
6819                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
6820                         ref_nested().clear();
6821                         }
6822                         return false;
6823
6824                 }
6825                 template<typename V> bool encode(size_t index, V& v) const
6826                 {
6827                         if(index != type) {return false;} return v(ref_nested());
6828
6829                 }
6830                 private:
6831                 size_t type {0};
6832
6833         };
6834
6835 };
6836 /*
6837 E-RABs-Admitted-ToBeAdded-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-ModAckItemIEs} }
6838 */
6839
6840 struct E_RABs_Admitted_ToBeAdded_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>
6841 {
6842         static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_ModAckList_elm";}
6843         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_ModAckItemIEs>;
6844
6845 };
6846 struct E_RABs_Admitted_ToBeAdded_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>
6847 {
6848         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-ModAckList";}
6849         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_ModAckList_elm>;
6850         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
6851
6852 };
6853 /*
6854 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6855         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
6856         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional},
6857         ...
6858 }
6859 */
6860
6861 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs
6862 {
6863         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6864         {
6865                 size_t get_index() const {return type;}
6866                 bool is_unknown() const { return type == 3; }
6867                 void clear() {type = 0;}
6868                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
6869                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
6870                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6871                 template<typename V>  bool decode(V& v)
6872                 {
6873                         clear();
6874                         if(!v(ref_nested())) return false;
6875                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
6876                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
6877                         else { type = 3; return true;}
6878                         return false;
6879
6880                 }
6881                 template<typename V> bool encode(V& v) const
6882                 {
6883                         return v(ref_nested());
6884
6885                 }
6886                 protected:
6887                 template<typename V>  bool decode(size_t index, V& v)
6888                 {
6889                         clear();
6890                         switch(index)
6891                         {
6892                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
6893                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
6894                         case 3: type = 3; return v(ref_nested());
6895                         ref_nested().clear();
6896                         }
6897                         return false;
6898
6899                 }
6900                 template<typename V> bool encode(size_t index, V& v) const
6901                 {
6902                         if(index != type) {return false;} return v(ref_nested());
6903
6904                 }
6905                 private:
6906                 size_t type {0};
6907
6908         };
6909         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6910         {
6911                 size_t get_index() const {return type;}
6912                 bool is_unknown() const { return type == 3; }
6913                 void clear() {type = 0;}
6914                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
6915                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
6916                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6917                 template<typename V>  bool decode(V& v)
6918                 {
6919                         clear();
6920                         if(!v(ref_nested())) return false;
6921                         if(equal(ignore)) { type = 1; return true; }
6922                         else if(equal(ignore)) { type = 2; return true; }
6923                         else { type = 3; return true;}
6924                         return false;
6925
6926                 }
6927                 template<typename V> bool encode(V& v) const
6928                 {
6929                         return v(ref_nested());
6930
6931                 }
6932                 protected:
6933                 template<typename V>  bool decode(size_t index, V& v)
6934                 {
6935                         clear();
6936                         switch(index)
6937                         {
6938                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
6939                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
6940                         case 3: type = 3; return v(ref_nested());
6941                         ref_nested().clear();
6942                         }
6943                         return false;
6944
6945                 }
6946                 template<typename V> bool encode(size_t index, V& v) const
6947                 {
6948                         if(index != type) {return false;} return v(ref_nested());
6949
6950                 }
6951                 private:
6952                 size_t type {0};
6953
6954         };
6955         struct Extension_t : asn::typefield<true>
6956         {
6957                 ~Extension_t()  {clear();}
6958                 size_t get_index() const {return type;}
6959                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
6960                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
6961                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
6962                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
6963                 bool is_unknown() const { return type == 3; }
6964                 void clear()
6965                 {
6966                         switch(type)
6967                         {
6968                         case 1: var.destroy<PDCPSnLength>(); break;
6969                         case 2: var.destroy<PDCPSnLength>(); break;
6970                         }
6971                         type = 0; ref_nested().clear();
6972                 }
6973                 template<typename V> static inline void enumerate(V& v)
6974                 {
6975                         v.template operator()<PDCPSnLength>(1);
6976                         v.template operator()<PDCPSnLength>(2);
6977
6978                 }
6979                 protected:
6980                 template<typename V> bool decode(size_t index, V& v)
6981                 {
6982                         clear();
6983                         switch(index)
6984                         {
6985                         case 1: v(select_id_uLpDCPSnLength()); return true;
6986                         case 2: v(select_id_dLPDCPSnLength()); return true;
6987                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
6988                         }
6989                         return false;
6990
6991                 }
6992                 template<typename V> bool encode(size_t index, V& v) const
6993                 {
6994                         if(index != type) return false;
6995                         switch(type)
6996                         {
6997                         case 1: v(var.as<PDCPSnLength>()); return true;
6998                         case 2: v(var.as<PDCPSnLength>()); return true;
6999                         }
7000                         return false;
7001
7002                 }
7003                 private:
7004                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7005                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7006                 union union_type
7007                 {
7008                         char dummy1[sizeof(PDCPSnLength)];
7009
7010                 };
7011                 asn::variant<sizeof(union_type)> var;
7012                 size_t type {0};
7013
7014         };
7015         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7016         {
7017                 size_t get_index() const {return type;}
7018                 bool is_unknown() const { return type == 3; }
7019                 void clear() {type = 0;}
7020                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
7021                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
7022                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7023                 template<typename V>  bool decode(V& v)
7024                 {
7025                         clear();
7026                         if(!v(ref_nested())) return false;
7027                         if(equal(optional)) { type = 1; return true; }
7028                         else if(equal(optional)) { type = 2; return true; }
7029                         else { type = 3; return true;}
7030                         return false;
7031
7032                 }
7033                 template<typename V> bool encode(V& v) const
7034                 {
7035                         return v(ref_nested());
7036
7037                 }
7038                 protected:
7039                 template<typename V>  bool decode(size_t index, V& v)
7040                 {
7041                         clear();
7042                         switch(index)
7043                         {
7044                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
7045                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
7046                         case 3: type = 3; return v(ref_nested());
7047                         ref_nested().clear();
7048                         }
7049                         return false;
7050
7051                 }
7052                 template<typename V> bool encode(size_t index, V& v) const
7053                 {
7054                         if(index != type) {return false;} return v(ref_nested());
7055
7056                 }
7057                 private:
7058                 size_t type {0};
7059
7060         };
7061
7062 };
7063 /*
7064 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent ::= SEQUENCE {
7065         s1-DL-GTPtunnelEndpoint                                 GTPtunnelEndpoint,
7066         sgNB-UL-GTP-TEIDatPDCP                                  GTPtunnelEndpoint                                                                                                                                                                               OPTIONAL,
7067 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
7068         rlc-Mode                                                                RLCMode                                                                                                                                                                                                 OPTIONAL,
7069 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
7070         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                                                               OPTIONAL,
7071         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                                                               OPTIONAL,
7072         mCG-E-RAB-Level-QoS-Parameters                  E-RAB-Level-QoS-Parameters                                                                                                                                                              OPTIONAL,
7073 -- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
7074         uL-Configuration                                                        ULConfiguration                                                                                                                                                                                 OPTIONAL,
7075 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
7076         iE-Extensions                                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresentExtIEs} }                     OPTIONAL,
7077         ...
7078 }
7079 */
7080
7081 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
7082 {
7083         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent";}
7084         using parent_t = asn::sequence<8, 0, true, 7>;
7085         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7086         {
7087                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
7088                 using parent_t = GTPtunnelEndpoint;
7089
7090         };
7091         s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
7092         s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
7093         struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
7094         {
7095                 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
7096                 using parent_t = GTPtunnelEndpoint;
7097                 static constexpr bool optional = true;
7098
7099         };
7100         sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
7101         sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
7102         struct rlc_Mode_t : RLCMode
7103         {
7104                 static constexpr const char* name() {return "rlc_Mode_t";}
7105                 using parent_t = RLCMode;
7106                 static constexpr bool optional = true;
7107
7108         };
7109         rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
7110         rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
7111         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7112         {
7113                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
7114                 using parent_t = GTPtunnelEndpoint;
7115                 static constexpr bool optional = true;
7116
7117         };
7118         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
7119         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
7120         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
7121         {
7122                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
7123                 using parent_t = GTPtunnelEndpoint;
7124                 static constexpr bool optional = true;
7125
7126         };
7127         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
7128         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
7129         struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
7130         {
7131                 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
7132                 using parent_t = E_RAB_Level_QoS_Parameters;
7133                 static constexpr bool optional = true;
7134
7135         };
7136         mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
7137         mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
7138         struct uL_Configuration_t : ULConfiguration
7139         {
7140                 static constexpr const char* name() {return "uL_Configuration_t";}
7141                 using parent_t = ULConfiguration;
7142                 static constexpr bool optional = true;
7143
7144         };
7145         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
7146         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
7147         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>
7148         {
7149                 static constexpr const char* name() {return "iE_Extensions_t";}
7150                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresentExtIEs>;
7151                 static constexpr bool optional = true;
7152
7153         };
7154         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7155         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7156         template<typename V> void decode(V& v)
7157         {
7158                 v(s1_DL_GTPtunnelEndpoint);
7159                 v(sgNB_UL_GTP_TEIDatPDCP);
7160                 v(rlc_Mode);
7161                 v(dL_Forwarding_GTPtunnelEndpoint);
7162                 v(uL_Forwarding_GTPtunnelEndpoint);
7163                 v(mCG_E_RAB_Level_QoS_Parameters);
7164                 v(uL_Configuration);
7165                 v(iE_Extensions);
7166
7167         };
7168         template<typename V> void encode(V& v) const
7169         {
7170                 v(s1_DL_GTPtunnelEndpoint);
7171                 v(sgNB_UL_GTP_TEIDatPDCP);
7172                 v(rlc_Mode);
7173                 v(dL_Forwarding_GTPtunnelEndpoint);
7174                 v(uL_Forwarding_GTPtunnelEndpoint);
7175                 v(mCG_E_RAB_Level_QoS_Parameters);
7176                 v(uL_Configuration);
7177                 v(iE_Extensions);
7178
7179         };
7180         void clear()
7181         {
7182                 s1_DL_GTPtunnelEndpoint.clear();
7183                 sgNB_UL_GTP_TEIDatPDCP.clear();
7184                 rlc_Mode.clear();
7185                 dL_Forwarding_GTPtunnelEndpoint.clear();
7186                 uL_Forwarding_GTPtunnelEndpoint.clear();
7187                 mCG_E_RAB_Level_QoS_Parameters.clear();
7188                 uL_Configuration.clear();
7189                 iE_Extensions.clear();
7190
7191         };
7192         private:
7193         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
7194         sgNB_UL_GTP_TEIDatPDCP_t        sgNB_UL_GTP_TEIDatPDCP;
7195         rlc_Mode_t      rlc_Mode;
7196         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
7197         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
7198         mCG_E_RAB_Level_QoS_Parameters_t        mCG_E_RAB_Level_QoS_Parameters;
7199         uL_Configuration_t      uL_Configuration;
7200         iE_Extensions_t iE_Extensions;
7201
7202 };
7203 /*
7204 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7205         { ID id-lCID                            CRITICALITY ignore      EXTENSION LCID                  PRESENCE optional},
7206         ...
7207 }
7208 */
7209
7210 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs
7211 {
7212         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7213         {
7214                 size_t get_index() const {return type;}
7215                 bool is_unknown() const { return type == 2; }
7216                 void clear() {type = 0;}
7217                 void select_id_lCID() { set(id_lCID); type=1;}
7218                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7219                 template<typename V>  bool decode(V& v)
7220                 {
7221                         clear();
7222                         if(!v(ref_nested())) return false;
7223                         if(equal(id_lCID)) { type = 1; return true; }
7224                         else { type = 2; return true;}
7225                         return false;
7226
7227                 }
7228                 template<typename V> bool encode(V& v) const
7229                 {
7230                         return v(ref_nested());
7231
7232                 }
7233                 protected:
7234                 template<typename V>  bool decode(size_t index, V& v)
7235                 {
7236                         clear();
7237                         switch(index)
7238                         {
7239                         case 1: type = 1; if(v(ref_nested())) { return equal(id_lCID);} return false;
7240                         case 2: type = 2; return v(ref_nested());
7241                         ref_nested().clear();
7242                         }
7243                         return false;
7244
7245                 }
7246                 template<typename V> bool encode(size_t index, V& v) const
7247                 {
7248                         if(index != type) {return false;} return v(ref_nested());
7249
7250                 }
7251                 private:
7252                 size_t type {0};
7253
7254         };
7255         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7256         {
7257                 size_t get_index() const {return type;}
7258                 bool is_unknown() const { return type == 2; }
7259                 void clear() {type = 0;}
7260                 void select_id_lCID() { set(ignore); type=1;}
7261                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7262                 template<typename V>  bool decode(V& v)
7263                 {
7264                         clear();
7265                         if(!v(ref_nested())) return false;
7266                         if(equal(ignore)) { type = 1; return true; }
7267                         else { type = 2; return true;}
7268                         return false;
7269
7270                 }
7271                 template<typename V> bool encode(V& v) const
7272                 {
7273                         return v(ref_nested());
7274
7275                 }
7276                 protected:
7277                 template<typename V>  bool decode(size_t index, V& v)
7278                 {
7279                         clear();
7280                         switch(index)
7281                         {
7282                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
7283                         case 2: type = 2; return v(ref_nested());
7284                         ref_nested().clear();
7285                         }
7286                         return false;
7287
7288                 }
7289                 template<typename V> bool encode(size_t index, V& v) const
7290                 {
7291                         if(index != type) {return false;} return v(ref_nested());
7292
7293                 }
7294                 private:
7295                 size_t type {0};
7296
7297         };
7298         struct Extension_t : asn::typefield<true>
7299         {
7300                 ~Extension_t()  {clear();}
7301                 size_t get_index() const {return type;}
7302                 LCID& select_id_lCID() { return set<LCID>(1); }
7303                 LCID const* get_id_lCID() const { return get<LCID>(1); }
7304                 bool is_unknown() const { return type == 2; }
7305                 void clear()
7306                 {
7307                         switch(type)
7308                         {
7309                         case 1: var.destroy<LCID>(); break;
7310                         }
7311                         type = 0; ref_nested().clear();
7312                 }
7313                 template<typename V> static inline void enumerate(V& v)
7314                 {
7315                         v.template operator()<LCID>(1);
7316
7317                 }
7318                 protected:
7319                 template<typename V> bool decode(size_t index, V& v)
7320                 {
7321                         clear();
7322                         switch(index)
7323                         {
7324                         case 1: v(select_id_lCID()); return true;
7325                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
7326                         }
7327                         return false;
7328
7329                 }
7330                 template<typename V> bool encode(size_t index, V& v) const
7331                 {
7332                         if(index != type) return false;
7333                         switch(type)
7334                         {
7335                         case 1: v(var.as<LCID>()); return true;
7336                         }
7337                         return false;
7338
7339                 }
7340                 private:
7341                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7342                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7343                 union union_type
7344                 {
7345                         char dummy1[sizeof(LCID)];
7346
7347                 };
7348                 asn::variant<sizeof(union_type)> var;
7349                 size_t type {0};
7350
7351         };
7352         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7353         {
7354                 size_t get_index() const {return type;}
7355                 bool is_unknown() const { return type == 2; }
7356                 void clear() {type = 0;}
7357                 void select_id_lCID() { set(optional); type=1;}
7358                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7359                 template<typename V>  bool decode(V& v)
7360                 {
7361                         clear();
7362                         if(!v(ref_nested())) return false;
7363                         if(equal(optional)) { type = 1; return true; }
7364                         else { type = 2; return true;}
7365                         return false;
7366
7367                 }
7368                 template<typename V> bool encode(V& v) const
7369                 {
7370                         return v(ref_nested());
7371
7372                 }
7373                 protected:
7374                 template<typename V>  bool decode(size_t index, V& v)
7375                 {
7376                         clear();
7377                         switch(index)
7378                         {
7379                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
7380                         case 2: type = 2; return v(ref_nested());
7381                         ref_nested().clear();
7382                         }
7383                         return false;
7384
7385                 }
7386                 template<typename V> bool encode(size_t index, V& v) const
7387                 {
7388                         if(index != type) {return false;} return v(ref_nested());
7389
7390                 }
7391                 private:
7392                 size_t type {0};
7393
7394         };
7395
7396 };
7397 /*
7398 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
7399         sgNB-DL-GTP-TEIDatSCG                           GTPtunnelEndpoint,
7400         secondary-sgNB-DL-GTP-TEIDatSCG         GTPtunnelEndpoint               OPTIONAL,
7401         iE-Extensions                                           ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresentExtIEs} }          OPTIONAL,
7402         ...
7403 }
7404 */
7405
7406 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
7407 {
7408         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent";}
7409         using parent_t = asn::sequence<3, 0, true, 2>;
7410         struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
7411         {
7412                 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
7413                 using parent_t = GTPtunnelEndpoint;
7414
7415         };
7416         sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
7417         sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
7418         struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
7419         {
7420                 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
7421                 using parent_t = GTPtunnelEndpoint;
7422                 static constexpr bool optional = true;
7423
7424         };
7425         secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
7426         secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
7427         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>
7428         {
7429                 static constexpr const char* name() {return "iE_Extensions_t";}
7430                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresentExtIEs>;
7431                 static constexpr bool optional = true;
7432
7433         };
7434         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7435         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7436         template<typename V> void decode(V& v)
7437         {
7438                 v(sgNB_DL_GTP_TEIDatSCG);
7439                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
7440                 v(iE_Extensions);
7441
7442         };
7443         template<typename V> void encode(V& v) const
7444         {
7445                 v(sgNB_DL_GTP_TEIDatSCG);
7446                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
7447                 v(iE_Extensions);
7448
7449         };
7450         void clear()
7451         {
7452                 sgNB_DL_GTP_TEIDatSCG.clear();
7453                 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
7454                 iE_Extensions.clear();
7455
7456         };
7457         private:
7458         sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
7459         secondary_sgNB_DL_GTP_TEIDatSCG_t       secondary_sgNB_DL_GTP_TEIDatSCG;
7460         iE_Extensions_t iE_Extensions;
7461
7462 };
7463 /*
7464 E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7465         ...
7466 }
7467 */
7468
7469 struct E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs
7470 {
7471         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7472         {
7473                 size_t get_index() const {return type;}
7474                 bool is_unknown() const { return type == 1; }
7475                 void clear() {type = 0;}
7476                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7477                 template<typename V>  bool decode(V& v)
7478                 {
7479                         clear();
7480                         if(!v(ref_nested())) return false;
7481                         { type = 1; return true;}
7482                         return false;
7483
7484                 }
7485                 template<typename V> bool encode(V& v) const
7486                 {
7487                         return v(ref_nested());
7488
7489                 }
7490                 protected:
7491                 template<typename V>  bool decode(size_t index, V& v)
7492                 {
7493                         clear();
7494                         switch(index)
7495                         {
7496                         case 1: type = 1; return v(ref_nested());
7497                         ref_nested().clear();
7498                         }
7499                         return false;
7500
7501                 }
7502                 template<typename V> bool encode(size_t index, V& v) const
7503                 {
7504                         if(index != type) {return false;} return v(ref_nested());
7505
7506                 }
7507                 private:
7508                 size_t type {0};
7509
7510         };
7511         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7512         {
7513                 size_t get_index() const {return type;}
7514                 bool is_unknown() const { return type == 1; }
7515                 void clear() {type = 0;}
7516                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7517                 template<typename V>  bool decode(V& v)
7518                 {
7519                         clear();
7520                         if(!v(ref_nested())) return false;
7521                         { type = 1; return true;}
7522                         return false;
7523
7524                 }
7525                 template<typename V> bool encode(V& v) const
7526                 {
7527                         return v(ref_nested());
7528
7529                 }
7530                 protected:
7531                 template<typename V>  bool decode(size_t index, V& v)
7532                 {
7533                         clear();
7534                         switch(index)
7535                         {
7536                         case 1: type = 1; return v(ref_nested());
7537                         ref_nested().clear();
7538                         }
7539                         return false;
7540
7541                 }
7542                 template<typename V> bool encode(size_t index, V& v) const
7543                 {
7544                         if(index != type) {return false;} return v(ref_nested());
7545
7546                 }
7547                 private:
7548                 size_t type {0};
7549
7550         };
7551         struct Extension_t : asn::typefield<true>
7552         {
7553                 ~Extension_t()  {clear();}
7554                 size_t get_index() const {return type;}
7555                 bool is_unknown() const { return type == 1; }
7556                 void clear()
7557                 {
7558                         type = 0; ref_nested().clear();
7559                 }
7560                 template<typename V> static inline void enumerate(V& v)
7561                 {
7562
7563                 }
7564                 protected:
7565                 template<typename V> bool decode(size_t index, V& v)
7566                 {
7567                         clear();
7568                         switch(index)
7569                         {
7570                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7571                         }
7572                         return false;
7573
7574                 }
7575                 template<typename V> bool encode(size_t index, V& v) const
7576                 {
7577                         if(index != type) return false;
7578                         return false;
7579
7580                 }
7581                 private:
7582                 size_t type {0};
7583
7584         };
7585         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7586         {
7587                 size_t get_index() const {return type;}
7588                 bool is_unknown() const { return type == 1; }
7589                 void clear() {type = 0;}
7590                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7591                 template<typename V>  bool decode(V& v)
7592                 {
7593                         clear();
7594                         if(!v(ref_nested())) return false;
7595                         { type = 1; return true;}
7596                         return false;
7597
7598                 }
7599                 template<typename V> bool encode(V& v) const
7600                 {
7601                         return v(ref_nested());
7602
7603                 }
7604                 protected:
7605                 template<typename V>  bool decode(size_t index, V& v)
7606                 {
7607                         clear();
7608                         switch(index)
7609                         {
7610                         case 1: type = 1; return v(ref_nested());
7611                         ref_nested().clear();
7612                         }
7613                         return false;
7614
7615                 }
7616                 template<typename V> bool encode(size_t index, V& v) const
7617                 {
7618                         if(index != type) {return false;} return v(ref_nested());
7619
7620                 }
7621                 private:
7622                 size_t type {0};
7623
7624         };
7625
7626 };
7627 /*
7628 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item ::= SEQUENCE {
7629         e-RAB-ID                                                                E-RAB-ID,
7630         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
7631         resource-configuration                          CHOICE {
7632                 sgNBPDCPpresent                                         E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPpresent,
7633                 sgNBPDCPnotpresent                                      E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item-SgNBPDCPnotpresent,
7634                 ...
7635         },
7636         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReqAck-ItemExtIEs} }      OPTIONAL,
7637         ...
7638 }
7639 */
7640
7641 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item : asn::sequence<4, 0, true, 1>
7642 {
7643         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item";}
7644         using parent_t = asn::sequence<4, 0, true, 1>;
7645         struct e_RAB_ID_t : E_RAB_ID
7646         {
7647                 static constexpr const char* name() {return "e_RAB_ID_t";}
7648                 using parent_t = E_RAB_ID;
7649
7650         };
7651         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
7652         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
7653         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
7654         {
7655                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
7656                 using parent_t = EN_DC_ResourceConfiguration;
7657
7658         };
7659         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
7660         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
7661         struct resource_configuration_t : asn::choice<2, 0, true>
7662         {
7663                 static constexpr const char* name() {return "resource_configuration_t";}
7664                 using parent_t = asn::choice<2, 0, true>;
7665                 index_type get_index() const {return index;}
7666                 bool is_unknown() const {return index == 3;}
7667                 void set_unknown() { set_index(3);  }
7668                 ~resource_configuration_t() {clear();}
7669                 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent
7670                 {
7671                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
7672                         using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent;
7673
7674                 };
7675                 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent
7676                 {
7677                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
7678                         using parent_t = E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent;
7679
7680                 };
7681                 void clear()
7682                 {
7683                         switch(get_index())
7684                         {
7685                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
7686                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
7687                         }
7688                         index = 0;
7689                         base::clear();
7690                 }
7691                 template<typename V> bool decode(size_t idx, V& v)
7692                 {
7693                         clear();
7694                         switch(idx)
7695                         {
7696                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
7697                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
7698                         }
7699                         return false;
7700
7701                 }
7702                 template<typename V> bool encode(V& v) const
7703                 {
7704                         switch(get_index())
7705                         {
7706                         case 1: return v(var.as<sgNBPDCPpresent_t>());
7707                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
7708                         }
7709                         return false;
7710                 }
7711                 template<typename V> static inline void enumerate(V& v)
7712                 {
7713                         v.template operator()<sgNBPDCPpresent_t>(1);
7714                         v.template operator()<sgNBPDCPnotpresent_t>(2);
7715
7716                 }
7717                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
7718                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
7719                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
7720                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
7721                 private:
7722                 void set_index(index_type i) {index = i; base::set();}
7723                 union union_type
7724                 {
7725                         char dummy1[sizeof(sgNBPDCPpresent_t)];
7726                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
7727
7728                 };
7729                 asn::variant<sizeof(union_type)>        var;
7730                 index_type      index {0};
7731         };
7732         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
7733         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
7734         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>
7735         {
7736                 static constexpr const char* name() {return "iE_Extensions_t";}
7737                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReqAck_ItemExtIEs>;
7738                 static constexpr bool optional = true;
7739
7740         };
7741         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7742         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7743         template<typename V> void decode(V& v)
7744         {
7745                 v(e_RAB_ID);
7746                 v(en_DC_ResourceConfiguration);
7747                 v(resource_configuration);
7748                 v(iE_Extensions);
7749
7750         };
7751         template<typename V> void encode(V& v) const
7752         {
7753                 v(e_RAB_ID);
7754                 v(en_DC_ResourceConfiguration);
7755                 v(resource_configuration);
7756                 v(iE_Extensions);
7757
7758         };
7759         void clear()
7760         {
7761                 e_RAB_ID.clear();
7762                 en_DC_ResourceConfiguration.clear();
7763                 resource_configuration.clear();
7764                 iE_Extensions.clear();
7765
7766         };
7767         private:
7768         e_RAB_ID_t      e_RAB_ID;
7769         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
7770         resource_configuration_t        resource_configuration;
7771         iE_Extensions_t iE_Extensions;
7772
7773 };
7774 /*
7775 E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
7776         { ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item    CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-Item               PRESENCE mandatory}
7777 }
7778 */
7779
7780 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs
7781 {
7782         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
7783         {
7784                 size_t get_index() const {return type;}
7785                 void clear() {type = 0;}
7786                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item); type=1;}
7787                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
7788                 template<typename V>  bool decode(V& v)
7789                 {
7790                         clear();
7791                         if(!v(ref_nested())) return false;
7792                         if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)) { type = 1; return true; }
7793                         return false;
7794
7795                 }
7796                 template<typename V> bool encode(V& v) const
7797                 {
7798                         return v(ref_nested());
7799
7800                 }
7801                 protected:
7802                 template<typename V>  bool decode(size_t index, V& v)
7803                 {
7804                         clear();
7805                         switch(index)
7806                         {
7807                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item);} return false;
7808                         ref_nested().clear();
7809                         }
7810                         return false;
7811
7812                 }
7813                 template<typename V> bool encode(size_t index, V& v) const
7814                 {
7815                         if(index != type) {return false;} return v(ref_nested());
7816
7817                 }
7818                 private:
7819                 size_t type {0};
7820
7821         };
7822         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
7823         {
7824                 size_t get_index() const {return type;}
7825                 void clear() {type = 0;}
7826                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(ignore); type=1;}
7827                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
7828                 template<typename V>  bool decode(V& v)
7829                 {
7830                         clear();
7831                         if(!v(ref_nested())) return false;
7832                         if(equal(ignore)) { type = 1; return true; }
7833                         return false;
7834
7835                 }
7836                 template<typename V> bool encode(V& v) const
7837                 {
7838                         return v(ref_nested());
7839
7840                 }
7841                 protected:
7842                 template<typename V>  bool decode(size_t index, V& v)
7843                 {
7844                         clear();
7845                         switch(index)
7846                         {
7847                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
7848                         ref_nested().clear();
7849                         }
7850                         return false;
7851
7852                 }
7853                 template<typename V> bool encode(size_t index, V& v) const
7854                 {
7855                         if(index != type) {return false;} return v(ref_nested());
7856
7857                 }
7858                 private:
7859                 size_t type {0};
7860
7861         };
7862         struct Value_t : asn::typefield<false>
7863         {
7864                 ~Value_t()      {clear();}
7865                 size_t get_index() const {return type;}
7866                 E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
7867                 E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1); }
7868                 void clear()
7869                 {
7870                         switch(type)
7871                         {
7872                         case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(); break;
7873                         }
7874                         type = 0; ref_nested().clear();
7875                 }
7876                 template<typename V> static inline void enumerate(V& v)
7877                 {
7878                         v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>(1);
7879
7880                 }
7881                 protected:
7882                 template<typename V> bool decode(size_t index, V& v)
7883                 {
7884                         clear();
7885                         switch(index)
7886                         {
7887                         case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item()); return true;
7888                         }
7889                         return false;
7890
7891                 }
7892                 template<typename V> bool encode(size_t index, V& v) const
7893                 {
7894                         if(index != type) return false;
7895                         switch(type)
7896                         {
7897                         case 1: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item>()); return true;
7898                         }
7899                         return false;
7900
7901                 }
7902                 private:
7903                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
7904                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
7905                 union union_type
7906                 {
7907                         char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item)];
7908
7909                 };
7910                 asn::variant<sizeof(union_type)> var;
7911                 size_t type {0};
7912
7913         };
7914         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
7915         {
7916                 size_t get_index() const {return type;}
7917                 void clear() {type = 0;}
7918                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item() { set(mandatory); type=1;}
7919                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
7920                 template<typename V>  bool decode(V& v)
7921                 {
7922                         clear();
7923                         if(!v(ref_nested())) return false;
7924                         if(equal(mandatory)) { type = 1; return true; }
7925                         return false;
7926
7927                 }
7928                 template<typename V> bool encode(V& v) const
7929                 {
7930                         return v(ref_nested());
7931
7932                 }
7933                 protected:
7934                 template<typename V>  bool decode(size_t index, V& v)
7935                 {
7936                         clear();
7937                         switch(index)
7938                         {
7939                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
7940                         ref_nested().clear();
7941                         }
7942                         return false;
7943
7944                 }
7945                 template<typename V> bool encode(size_t index, V& v) const
7946                 {
7947                         if(index != type) {return false;} return v(ref_nested());
7948
7949                 }
7950                 private:
7951                 size_t type {0};
7952
7953         };
7954
7955 };
7956 /*
7957 E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBAddReqAck-ItemIEs} }
7958 */
7959
7960 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>
7961 {
7962         static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm";}
7963         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs>;
7964
7965 };
7966 struct E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>
7967 {
7968         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList";}
7969         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_elm>;
7970         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
7971
7972 };
7973 /*
7974 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7975         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
7976         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional},
7977         ...
7978 }
7979 */
7980
7981 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs
7982 {
7983         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7984         {
7985                 size_t get_index() const {return type;}
7986                 bool is_unknown() const { return type == 3; }
7987                 void clear() {type = 0;}
7988                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
7989                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
7990                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7991                 template<typename V>  bool decode(V& v)
7992                 {
7993                         clear();
7994                         if(!v(ref_nested())) return false;
7995                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
7996                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
7997                         else { type = 3; return true;}
7998                         return false;
7999
8000                 }
8001                 template<typename V> bool encode(V& v) const
8002                 {
8003                         return v(ref_nested());
8004
8005                 }
8006                 protected:
8007                 template<typename V>  bool decode(size_t index, V& v)
8008                 {
8009                         clear();
8010                         switch(index)
8011                         {
8012                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
8013                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
8014                         case 3: type = 3; return v(ref_nested());
8015                         ref_nested().clear();
8016                         }
8017                         return false;
8018
8019                 }
8020                 template<typename V> bool encode(size_t index, V& v) const
8021                 {
8022                         if(index != type) {return false;} return v(ref_nested());
8023
8024                 }
8025                 private:
8026                 size_t type {0};
8027
8028         };
8029         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8030         {
8031                 size_t get_index() const {return type;}
8032                 bool is_unknown() const { return type == 3; }
8033                 void clear() {type = 0;}
8034                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
8035                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
8036                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8037                 template<typename V>  bool decode(V& v)
8038                 {
8039                         clear();
8040                         if(!v(ref_nested())) return false;
8041                         if(equal(ignore)) { type = 1; return true; }
8042                         else if(equal(ignore)) { type = 2; return true; }
8043                         else { type = 3; return true;}
8044                         return false;
8045
8046                 }
8047                 template<typename V> bool encode(V& v) const
8048                 {
8049                         return v(ref_nested());
8050
8051                 }
8052                 protected:
8053                 template<typename V>  bool decode(size_t index, V& v)
8054                 {
8055                         clear();
8056                         switch(index)
8057                         {
8058                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8059                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
8060                         case 3: type = 3; return v(ref_nested());
8061                         ref_nested().clear();
8062                         }
8063                         return false;
8064
8065                 }
8066                 template<typename V> bool encode(size_t index, V& v) const
8067                 {
8068                         if(index != type) {return false;} return v(ref_nested());
8069
8070                 }
8071                 private:
8072                 size_t type {0};
8073
8074         };
8075         struct Extension_t : asn::typefield<true>
8076         {
8077                 ~Extension_t()  {clear();}
8078                 size_t get_index() const {return type;}
8079                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
8080                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
8081                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
8082                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
8083                 bool is_unknown() const { return type == 3; }
8084                 void clear()
8085                 {
8086                         switch(type)
8087                         {
8088                         case 1: var.destroy<PDCPSnLength>(); break;
8089                         case 2: var.destroy<PDCPSnLength>(); break;
8090                         }
8091                         type = 0; ref_nested().clear();
8092                 }
8093                 template<typename V> static inline void enumerate(V& v)
8094                 {
8095                         v.template operator()<PDCPSnLength>(1);
8096                         v.template operator()<PDCPSnLength>(2);
8097
8098                 }
8099                 protected:
8100                 template<typename V> bool decode(size_t index, V& v)
8101                 {
8102                         clear();
8103                         switch(index)
8104                         {
8105                         case 1: v(select_id_uLpDCPSnLength()); return true;
8106                         case 2: v(select_id_dLPDCPSnLength()); return true;
8107                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
8108                         }
8109                         return false;
8110
8111                 }
8112                 template<typename V> bool encode(size_t index, V& v) const
8113                 {
8114                         if(index != type) return false;
8115                         switch(type)
8116                         {
8117                         case 1: v(var.as<PDCPSnLength>()); return true;
8118                         case 2: v(var.as<PDCPSnLength>()); return true;
8119                         }
8120                         return false;
8121
8122                 }
8123                 private:
8124                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
8125                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
8126                 union union_type
8127                 {
8128                         char dummy1[sizeof(PDCPSnLength)];
8129
8130                 };
8131                 asn::variant<sizeof(union_type)> var;
8132                 size_t type {0};
8133
8134         };
8135         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8136         {
8137                 size_t get_index() const {return type;}
8138                 bool is_unknown() const { return type == 3; }
8139                 void clear() {type = 0;}
8140                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
8141                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
8142                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8143                 template<typename V>  bool decode(V& v)
8144                 {
8145                         clear();
8146                         if(!v(ref_nested())) return false;
8147                         if(equal(optional)) { type = 1; return true; }
8148                         else if(equal(optional)) { type = 2; return true; }
8149                         else { type = 3; return true;}
8150                         return false;
8151
8152                 }
8153                 template<typename V> bool encode(V& v) const
8154                 {
8155                         return v(ref_nested());
8156
8157                 }
8158                 protected:
8159                 template<typename V>  bool decode(size_t index, V& v)
8160                 {
8161                         clear();
8162                         switch(index)
8163                         {
8164                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
8165                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
8166                         case 3: type = 3; return v(ref_nested());
8167                         ref_nested().clear();
8168                         }
8169                         return false;
8170
8171                 }
8172                 template<typename V> bool encode(size_t index, V& v) const
8173                 {
8174                         if(index != type) {return false;} return v(ref_nested());
8175
8176                 }
8177                 private:
8178                 size_t type {0};
8179
8180         };
8181
8182 };
8183 /*
8184 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
8185         s1-DL-GTPtunnelEndpoint                                 GTPtunnelEndpoint,
8186         sgNB-UL-GTP-TEIDatPDCP                                  GTPtunnelEndpoint                                                                                                                                                                       OPTIONAL,
8187 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
8188         rlc-Mode                                                                        RLCMode                                                                                                                                                                                         OPTIONAL,
8189 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE are set to “present” --
8190         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                                                       OPTIONAL,
8191         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                                                       OPTIONAL,
8192         mCG-E-RAB-Level-QoS-Parameters                  E-RAB-Level-QoS-Parameters                                                                                                                                                      OPTIONAL,
8193 -- This IE shall be present if MCG resource and SCG resource IEs in the the EN-DC Resource Configuration IE are set to “present” and the GBR QoS Information IE is present in the Requested MCG E-RAB Level QoS Parameters IE --
8194         uL-Configuration                                                ULConfiguration                                                                                                                                                                                 OPTIONAL,
8195 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
8196         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresentExtIEs} }                OPTIONAL,
8197         ...
8198 }
8199 */
8200
8201 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<8, 0, true, 7>
8202 {
8203         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent";}
8204         using parent_t = asn::sequence<8, 0, true, 7>;
8205         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8206         {
8207                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
8208                 using parent_t = GTPtunnelEndpoint;
8209
8210         };
8211         s1_DL_GTPtunnelEndpoint_t& ref_s1_DL_GTPtunnelEndpoint() {return s1_DL_GTPtunnelEndpoint;}
8212         s1_DL_GTPtunnelEndpoint_t const& ref_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint;}
8213         struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
8214         {
8215                 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
8216                 using parent_t = GTPtunnelEndpoint;
8217                 static constexpr bool optional = true;
8218
8219         };
8220         sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
8221         sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
8222         struct rlc_Mode_t : RLCMode
8223         {
8224                 static constexpr const char* name() {return "rlc_Mode_t";}
8225                 using parent_t = RLCMode;
8226                 static constexpr bool optional = true;
8227
8228         };
8229         rlc_Mode_t& set_rlc_Mode() { rlc_Mode.setpresent(true); return rlc_Mode;}
8230         rlc_Mode_t const* get_rlc_Mode() const {return rlc_Mode.is_valid() ? &rlc_Mode : nullptr;}
8231         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8232         {
8233                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
8234                 using parent_t = GTPtunnelEndpoint;
8235                 static constexpr bool optional = true;
8236
8237         };
8238         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
8239         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
8240         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
8241         {
8242                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
8243                 using parent_t = GTPtunnelEndpoint;
8244                 static constexpr bool optional = true;
8245
8246         };
8247         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
8248         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
8249         struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
8250         {
8251                 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
8252                 using parent_t = E_RAB_Level_QoS_Parameters;
8253                 static constexpr bool optional = true;
8254
8255         };
8256         mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
8257         mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
8258         struct uL_Configuration_t : ULConfiguration
8259         {
8260                 static constexpr const char* name() {return "uL_Configuration_t";}
8261                 using parent_t = ULConfiguration;
8262                 static constexpr bool optional = true;
8263
8264         };
8265         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
8266         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
8267         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
8268         {
8269                 static constexpr const char* name() {return "iE_Extensions_t";}
8270                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
8271                 static constexpr bool optional = true;
8272
8273         };
8274         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8275         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8276         template<typename V> void decode(V& v)
8277         {
8278                 v(s1_DL_GTPtunnelEndpoint);
8279                 v(sgNB_UL_GTP_TEIDatPDCP);
8280                 v(rlc_Mode);
8281                 v(dL_Forwarding_GTPtunnelEndpoint);
8282                 v(uL_Forwarding_GTPtunnelEndpoint);
8283                 v(mCG_E_RAB_Level_QoS_Parameters);
8284                 v(uL_Configuration);
8285                 v(iE_Extensions);
8286
8287         };
8288         template<typename V> void encode(V& v) const
8289         {
8290                 v(s1_DL_GTPtunnelEndpoint);
8291                 v(sgNB_UL_GTP_TEIDatPDCP);
8292                 v(rlc_Mode);
8293                 v(dL_Forwarding_GTPtunnelEndpoint);
8294                 v(uL_Forwarding_GTPtunnelEndpoint);
8295                 v(mCG_E_RAB_Level_QoS_Parameters);
8296                 v(uL_Configuration);
8297                 v(iE_Extensions);
8298
8299         };
8300         void clear()
8301         {
8302                 s1_DL_GTPtunnelEndpoint.clear();
8303                 sgNB_UL_GTP_TEIDatPDCP.clear();
8304                 rlc_Mode.clear();
8305                 dL_Forwarding_GTPtunnelEndpoint.clear();
8306                 uL_Forwarding_GTPtunnelEndpoint.clear();
8307                 mCG_E_RAB_Level_QoS_Parameters.clear();
8308                 uL_Configuration.clear();
8309                 iE_Extensions.clear();
8310
8311         };
8312         private:
8313         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
8314         sgNB_UL_GTP_TEIDatPDCP_t        sgNB_UL_GTP_TEIDatPDCP;
8315         rlc_Mode_t      rlc_Mode;
8316         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
8317         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
8318         mCG_E_RAB_Level_QoS_Parameters_t        mCG_E_RAB_Level_QoS_Parameters;
8319         uL_Configuration_t      uL_Configuration;
8320         iE_Extensions_t iE_Extensions;
8321
8322 };
8323 /*
8324 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8325         {ID id-lCID                             CRITICALITY ignore      EXTENSION LCID          PRESENCE optional},
8326         ...
8327 }
8328 */
8329
8330 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
8331 {
8332         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8333         {
8334                 size_t get_index() const {return type;}
8335                 bool is_unknown() const { return type == 2; }
8336                 void clear() {type = 0;}
8337                 void select_id_lCID() { set(id_lCID); type=1;}
8338                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8339                 template<typename V>  bool decode(V& v)
8340                 {
8341                         clear();
8342                         if(!v(ref_nested())) return false;
8343                         if(equal(id_lCID)) { type = 1; return true; }
8344                         else { type = 2; return true;}
8345                         return false;
8346
8347                 }
8348                 template<typename V> bool encode(V& v) const
8349                 {
8350                         return v(ref_nested());
8351
8352                 }
8353                 protected:
8354                 template<typename V>  bool decode(size_t index, V& v)
8355                 {
8356                         clear();
8357                         switch(index)
8358                         {
8359                         case 1: type = 1; if(v(ref_nested())) { return equal(id_lCID);} return false;
8360                         case 2: type = 2; return v(ref_nested());
8361                         ref_nested().clear();
8362                         }
8363                         return false;
8364
8365                 }
8366                 template<typename V> bool encode(size_t index, V& v) const
8367                 {
8368                         if(index != type) {return false;} return v(ref_nested());
8369
8370                 }
8371                 private:
8372                 size_t type {0};
8373
8374         };
8375         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8376         {
8377                 size_t get_index() const {return type;}
8378                 bool is_unknown() const { return type == 2; }
8379                 void clear() {type = 0;}
8380                 void select_id_lCID() { set(ignore); type=1;}
8381                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8382                 template<typename V>  bool decode(V& v)
8383                 {
8384                         clear();
8385                         if(!v(ref_nested())) return false;
8386                         if(equal(ignore)) { type = 1; return true; }
8387                         else { type = 2; return true;}
8388                         return false;
8389
8390                 }
8391                 template<typename V> bool encode(V& v) const
8392                 {
8393                         return v(ref_nested());
8394
8395                 }
8396                 protected:
8397                 template<typename V>  bool decode(size_t index, V& v)
8398                 {
8399                         clear();
8400                         switch(index)
8401                         {
8402                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8403                         case 2: type = 2; return v(ref_nested());
8404                         ref_nested().clear();
8405                         }
8406                         return false;
8407
8408                 }
8409                 template<typename V> bool encode(size_t index, V& v) const
8410                 {
8411                         if(index != type) {return false;} return v(ref_nested());
8412
8413                 }
8414                 private:
8415                 size_t type {0};
8416
8417         };
8418         struct Extension_t : asn::typefield<true>
8419         {
8420                 ~Extension_t()  {clear();}
8421                 size_t get_index() const {return type;}
8422                 LCID& select_id_lCID() { return set<LCID>(1); }
8423                 LCID const* get_id_lCID() const { return get<LCID>(1); }
8424                 bool is_unknown() const { return type == 2; }
8425                 void clear()
8426                 {
8427                         switch(type)
8428                         {
8429                         case 1: var.destroy<LCID>(); break;
8430                         }
8431                         type = 0; ref_nested().clear();
8432                 }
8433                 template<typename V> static inline void enumerate(V& v)
8434                 {
8435                         v.template operator()<LCID>(1);
8436
8437                 }
8438                 protected:
8439                 template<typename V> bool decode(size_t index, V& v)
8440                 {
8441                         clear();
8442                         switch(index)
8443                         {
8444                         case 1: v(select_id_lCID()); return true;
8445                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
8446                         }
8447                         return false;
8448
8449                 }
8450                 template<typename V> bool encode(size_t index, V& v) const
8451                 {
8452                         if(index != type) return false;
8453                         switch(type)
8454                         {
8455                         case 1: v(var.as<LCID>()); return true;
8456                         }
8457                         return false;
8458
8459                 }
8460                 private:
8461                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
8462                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
8463                 union union_type
8464                 {
8465                         char dummy1[sizeof(LCID)];
8466
8467                 };
8468                 asn::variant<sizeof(union_type)> var;
8469                 size_t type {0};
8470
8471         };
8472         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8473         {
8474                 size_t get_index() const {return type;}
8475                 bool is_unknown() const { return type == 2; }
8476                 void clear() {type = 0;}
8477                 void select_id_lCID() { set(optional); type=1;}
8478                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8479                 template<typename V>  bool decode(V& v)
8480                 {
8481                         clear();
8482                         if(!v(ref_nested())) return false;
8483                         if(equal(optional)) { type = 1; return true; }
8484                         else { type = 2; return true;}
8485                         return false;
8486
8487                 }
8488                 template<typename V> bool encode(V& v) const
8489                 {
8490                         return v(ref_nested());
8491
8492                 }
8493                 protected:
8494                 template<typename V>  bool decode(size_t index, V& v)
8495                 {
8496                         clear();
8497                         switch(index)
8498                         {
8499                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
8500                         case 2: type = 2; return v(ref_nested());
8501                         ref_nested().clear();
8502                         }
8503                         return false;
8504
8505                 }
8506                 template<typename V> bool encode(size_t index, V& v) const
8507                 {
8508                         if(index != type) {return false;} return v(ref_nested());
8509
8510                 }
8511                 private:
8512                 size_t type {0};
8513
8514         };
8515
8516 };
8517 /*
8518 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
8519         sgNB-DL-GTP-TEIDatSCG                                   GTPtunnelEndpoint,
8520         secondary-sgNB-DL-GTP-TEIDatSCG                 GTPtunnelEndpoint                       OPTIONAL,
8521         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
8522         ...
8523 }
8524 */
8525
8526 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 2>
8527 {
8528         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent";}
8529         using parent_t = asn::sequence<3, 0, true, 2>;
8530         struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
8531         {
8532                 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
8533                 using parent_t = GTPtunnelEndpoint;
8534
8535         };
8536         sgNB_DL_GTP_TEIDatSCG_t& ref_sgNB_DL_GTP_TEIDatSCG() {return sgNB_DL_GTP_TEIDatSCG;}
8537         sgNB_DL_GTP_TEIDatSCG_t const& ref_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG;}
8538         struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
8539         {
8540                 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
8541                 using parent_t = GTPtunnelEndpoint;
8542                 static constexpr bool optional = true;
8543
8544         };
8545         secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
8546         secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
8547         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
8548         {
8549                 static constexpr const char* name() {return "iE_Extensions_t";}
8550                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
8551                 static constexpr bool optional = true;
8552
8553         };
8554         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8555         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8556         template<typename V> void decode(V& v)
8557         {
8558                 v(sgNB_DL_GTP_TEIDatSCG);
8559                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
8560                 v(iE_Extensions);
8561
8562         };
8563         template<typename V> void encode(V& v) const
8564         {
8565                 v(sgNB_DL_GTP_TEIDatSCG);
8566                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
8567                 v(iE_Extensions);
8568
8569         };
8570         void clear()
8571         {
8572                 sgNB_DL_GTP_TEIDatSCG.clear();
8573                 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
8574                 iE_Extensions.clear();
8575
8576         };
8577         private:
8578         sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
8579         secondary_sgNB_DL_GTP_TEIDatSCG_t       secondary_sgNB_DL_GTP_TEIDatSCG;
8580         iE_Extensions_t iE_Extensions;
8581
8582 };
8583 /*
8584 E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8585         ...
8586 }
8587 */
8588
8589 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs
8590 {
8591         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8592         {
8593                 size_t get_index() const {return type;}
8594                 bool is_unknown() const { return type == 1; }
8595                 void clear() {type = 0;}
8596                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8597                 template<typename V>  bool decode(V& v)
8598                 {
8599                         clear();
8600                         if(!v(ref_nested())) return false;
8601                         { type = 1; return true;}
8602                         return false;
8603
8604                 }
8605                 template<typename V> bool encode(V& v) const
8606                 {
8607                         return v(ref_nested());
8608
8609                 }
8610                 protected:
8611                 template<typename V>  bool decode(size_t index, V& v)
8612                 {
8613                         clear();
8614                         switch(index)
8615                         {
8616                         case 1: type = 1; return v(ref_nested());
8617                         ref_nested().clear();
8618                         }
8619                         return false;
8620
8621                 }
8622                 template<typename V> bool encode(size_t index, V& v) const
8623                 {
8624                         if(index != type) {return false;} return v(ref_nested());
8625
8626                 }
8627                 private:
8628                 size_t type {0};
8629
8630         };
8631         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8632         {
8633                 size_t get_index() const {return type;}
8634                 bool is_unknown() const { return type == 1; }
8635                 void clear() {type = 0;}
8636                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8637                 template<typename V>  bool decode(V& v)
8638                 {
8639                         clear();
8640                         if(!v(ref_nested())) return false;
8641                         { type = 1; return true;}
8642                         return false;
8643
8644                 }
8645                 template<typename V> bool encode(V& v) const
8646                 {
8647                         return v(ref_nested());
8648
8649                 }
8650                 protected:
8651                 template<typename V>  bool decode(size_t index, V& v)
8652                 {
8653                         clear();
8654                         switch(index)
8655                         {
8656                         case 1: type = 1; return v(ref_nested());
8657                         ref_nested().clear();
8658                         }
8659                         return false;
8660
8661                 }
8662                 template<typename V> bool encode(size_t index, V& v) const
8663                 {
8664                         if(index != type) {return false;} return v(ref_nested());
8665
8666                 }
8667                 private:
8668                 size_t type {0};
8669
8670         };
8671         struct Extension_t : asn::typefield<true>
8672         {
8673                 ~Extension_t()  {clear();}
8674                 size_t get_index() const {return type;}
8675                 bool is_unknown() const { return type == 1; }
8676                 void clear()
8677                 {
8678                         type = 0; ref_nested().clear();
8679                 }
8680                 template<typename V> static inline void enumerate(V& v)
8681                 {
8682
8683                 }
8684                 protected:
8685                 template<typename V> bool decode(size_t index, V& v)
8686                 {
8687                         clear();
8688                         switch(index)
8689                         {
8690                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8691                         }
8692                         return false;
8693
8694                 }
8695                 template<typename V> bool encode(size_t index, V& v) const
8696                 {
8697                         if(index != type) return false;
8698                         return false;
8699
8700                 }
8701                 private:
8702                 size_t type {0};
8703
8704         };
8705         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8706         {
8707                 size_t get_index() const {return type;}
8708                 bool is_unknown() const { return type == 1; }
8709                 void clear() {type = 0;}
8710                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8711                 template<typename V>  bool decode(V& v)
8712                 {
8713                         clear();
8714                         if(!v(ref_nested())) return false;
8715                         { type = 1; return true;}
8716                         return false;
8717
8718                 }
8719                 template<typename V> bool encode(V& v) const
8720                 {
8721                         return v(ref_nested());
8722
8723                 }
8724                 protected:
8725                 template<typename V>  bool decode(size_t index, V& v)
8726                 {
8727                         clear();
8728                         switch(index)
8729                         {
8730                         case 1: type = 1; return v(ref_nested());
8731                         ref_nested().clear();
8732                         }
8733                         return false;
8734
8735                 }
8736                 template<typename V> bool encode(size_t index, V& v) const
8737                 {
8738                         if(index != type) {return false;} return v(ref_nested());
8739
8740                 }
8741                 private:
8742                 size_t type {0};
8743
8744         };
8745
8746 };
8747 /*
8748 E-RABs-Admitted-ToBeAdded-SgNBModAck-Item ::= SEQUENCE {
8749         e-RAB-ID                                                                E-RAB-ID,
8750         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
8751         resource-configuration                          CHOICE {
8752                 sgNBPDCPpresent                                         E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPpresent,
8753                 sgNBPDCPnotpresent                                      E-RABs-Admitted-ToBeAdded-SgNBModAck-Item-SgNBPDCPnotpresent,
8754                 ...
8755         },
8756         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemExtIEs} }        OPTIONAL,
8757         ...
8758 }
8759 */
8760
8761 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
8762 {
8763         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAck-Item";}
8764         using parent_t = asn::sequence<4, 0, true, 1>;
8765         struct e_RAB_ID_t : E_RAB_ID
8766         {
8767                 static constexpr const char* name() {return "e_RAB_ID_t";}
8768                 using parent_t = E_RAB_ID;
8769
8770         };
8771         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
8772         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
8773         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
8774         {
8775                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
8776                 using parent_t = EN_DC_ResourceConfiguration;
8777
8778         };
8779         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
8780         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
8781         struct resource_configuration_t : asn::choice<2, 0, true>
8782         {
8783                 static constexpr const char* name() {return "resource_configuration_t";}
8784                 using parent_t = asn::choice<2, 0, true>;
8785                 index_type get_index() const {return index;}
8786                 bool is_unknown() const {return index == 3;}
8787                 void set_unknown() { set_index(3);  }
8788                 ~resource_configuration_t() {clear();}
8789                 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent
8790                 {
8791                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
8792                         using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPpresent;
8793
8794                 };
8795                 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent
8796                 {
8797                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
8798                         using parent_t = E_RABs_Admitted_ToBeAdded_SgNBModAck_Item_SgNBPDCPnotpresent;
8799
8800                 };
8801                 void clear()
8802                 {
8803                         switch(get_index())
8804                         {
8805                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
8806                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
8807                         }
8808                         index = 0;
8809                         base::clear();
8810                 }
8811                 template<typename V> bool decode(size_t idx, V& v)
8812                 {
8813                         clear();
8814                         switch(idx)
8815                         {
8816                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
8817                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
8818                         }
8819                         return false;
8820
8821                 }
8822                 template<typename V> bool encode(V& v) const
8823                 {
8824                         switch(get_index())
8825                         {
8826                         case 1: return v(var.as<sgNBPDCPpresent_t>());
8827                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
8828                         }
8829                         return false;
8830                 }
8831                 template<typename V> static inline void enumerate(V& v)
8832                 {
8833                         v.template operator()<sgNBPDCPpresent_t>(1);
8834                         v.template operator()<sgNBPDCPnotpresent_t>(2);
8835
8836                 }
8837                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
8838                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
8839                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
8840                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
8841                 private:
8842                 void set_index(index_type i) {index = i; base::set();}
8843                 union union_type
8844                 {
8845                         char dummy1[sizeof(sgNBPDCPpresent_t)];
8846                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
8847
8848                 };
8849                 asn::variant<sizeof(union_type)>        var;
8850                 index_type      index {0};
8851         };
8852         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
8853         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
8854         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>
8855         {
8856                 static constexpr const char* name() {return "iE_Extensions_t";}
8857                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemExtIEs>;
8858                 static constexpr bool optional = true;
8859
8860         };
8861         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8862         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8863         template<typename V> void decode(V& v)
8864         {
8865                 v(e_RAB_ID);
8866                 v(en_DC_ResourceConfiguration);
8867                 v(resource_configuration);
8868                 v(iE_Extensions);
8869
8870         };
8871         template<typename V> void encode(V& v) const
8872         {
8873                 v(e_RAB_ID);
8874                 v(en_DC_ResourceConfiguration);
8875                 v(resource_configuration);
8876                 v(iE_Extensions);
8877
8878         };
8879         void clear()
8880         {
8881                 e_RAB_ID.clear();
8882                 en_DC_ResourceConfiguration.clear();
8883                 resource_configuration.clear();
8884                 iE_Extensions.clear();
8885
8886         };
8887         private:
8888         e_RAB_ID_t      e_RAB_ID;
8889         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
8890         resource_configuration_t        resource_configuration;
8891         iE_Extensions_t iE_Extensions;
8892
8893 };
8894 /*
8895 E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
8896         { ID id-E-RABs-Admitted-ToBeAdded-SgNBModAck-Item       CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-SgNBModAck-Item          PRESENCE mandatory}
8897 }
8898 */
8899
8900 struct E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs
8901 {
8902         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
8903         {
8904                 size_t get_index() const {return type;}
8905                 void clear() {type = 0;}
8906                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item); type=1;}
8907                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
8908                 template<typename V>  bool decode(V& v)
8909                 {
8910                         clear();
8911                         if(!v(ref_nested())) return false;
8912                         if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item)) { type = 1; return true; }
8913                         return false;
8914
8915                 }
8916                 template<typename V> bool encode(V& v) const
8917                 {
8918                         return v(ref_nested());
8919
8920                 }
8921                 protected:
8922                 template<typename V>  bool decode(size_t index, V& v)
8923                 {
8924                         clear();
8925                         switch(index)
8926                         {
8927                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item);} return false;
8928                         ref_nested().clear();
8929                         }
8930                         return false;
8931
8932                 }
8933                 template<typename V> bool encode(size_t index, V& v) const
8934                 {
8935                         if(index != type) {return false;} return v(ref_nested());
8936
8937                 }
8938                 private:
8939                 size_t type {0};
8940
8941         };
8942         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
8943         {
8944                 size_t get_index() const {return type;}
8945                 void clear() {type = 0;}
8946                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(ignore); type=1;}
8947                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
8948                 template<typename V>  bool decode(V& v)
8949                 {
8950                         clear();
8951                         if(!v(ref_nested())) return false;
8952                         if(equal(ignore)) { type = 1; return true; }
8953                         return false;
8954
8955                 }
8956                 template<typename V> bool encode(V& v) const
8957                 {
8958                         return v(ref_nested());
8959
8960                 }
8961                 protected:
8962                 template<typename V>  bool decode(size_t index, V& v)
8963                 {
8964                         clear();
8965                         switch(index)
8966                         {
8967                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
8968                         ref_nested().clear();
8969                         }
8970                         return false;
8971
8972                 }
8973                 template<typename V> bool encode(size_t index, V& v) const
8974                 {
8975                         if(index != type) {return false;} return v(ref_nested());
8976
8977                 }
8978                 private:
8979                 size_t type {0};
8980
8981         };
8982         struct Value_t : asn::typefield<false>
8983         {
8984                 ~Value_t()      {clear();}
8985                 size_t get_index() const {return type;}
8986                 E_RABs_Admitted_ToBeAdded_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
8987                 E_RABs_Admitted_ToBeAdded_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1); }
8988                 void clear()
8989                 {
8990                         switch(type)
8991                         {
8992                         case 1: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(); break;
8993                         }
8994                         type = 0; ref_nested().clear();
8995                 }
8996                 template<typename V> static inline void enumerate(V& v)
8997                 {
8998                         v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>(1);
8999
9000                 }
9001                 protected:
9002                 template<typename V> bool decode(size_t index, V& v)
9003                 {
9004                         clear();
9005                         switch(index)
9006                         {
9007                         case 1: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item()); return true;
9008                         }
9009                         return false;
9010
9011                 }
9012                 template<typename V> bool encode(size_t index, V& v) const
9013                 {
9014                         if(index != type) return false;
9015                         switch(type)
9016                         {
9017                         case 1: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBModAck_Item>()); return true;
9018                         }
9019                         return false;
9020
9021                 }
9022                 private:
9023                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9024                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9025                 union union_type
9026                 {
9027                         char dummy1[sizeof(E_RABs_Admitted_ToBeAdded_SgNBModAck_Item)];
9028
9029                 };
9030                 asn::variant<sizeof(union_type)> var;
9031                 size_t type {0};
9032
9033         };
9034         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
9035         {
9036                 size_t get_index() const {return type;}
9037                 void clear() {type = 0;}
9038                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAck_Item() { set(mandatory); type=1;}
9039                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
9040                 template<typename V>  bool decode(V& v)
9041                 {
9042                         clear();
9043                         if(!v(ref_nested())) return false;
9044                         if(equal(mandatory)) { type = 1; return true; }
9045                         return false;
9046
9047                 }
9048                 template<typename V> bool encode(V& v) const
9049                 {
9050                         return v(ref_nested());
9051
9052                 }
9053                 protected:
9054                 template<typename V>  bool decode(size_t index, V& v)
9055                 {
9056                         clear();
9057                         switch(index)
9058                         {
9059                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
9060                         ref_nested().clear();
9061                         }
9062                         return false;
9063
9064                 }
9065                 template<typename V> bool encode(size_t index, V& v) const
9066                 {
9067                         if(index != type) {return false;} return v(ref_nested());
9068
9069                 }
9070                 private:
9071                 size_t type {0};
9072
9073         };
9074
9075 };
9076 /*
9077 E-RABs-Admitted-ToBeAdded-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeAdded-SgNBModAck-ItemIEs} }
9078 */
9079
9080 struct E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>
9081 {
9082         static constexpr const char* name() {return "E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm";}
9083         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeAdded_SgNBModAck_ItemIEs>;
9084
9085 };
9086 struct E_RABs_Admitted_ToBeAdded_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>
9087 {
9088         static constexpr const char* name() {return "E-RABs-Admitted-ToBeAdded-SgNBModAckList";}
9089         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeAdded_SgNBModAckList_elm>;
9090         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
9091
9092 };
9093 /*
9094 E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9095         ...
9096 }
9097 */
9098
9099 struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs
9100 {
9101         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9102         {
9103                 size_t get_index() const {return type;}
9104                 bool is_unknown() const { return type == 1; }
9105                 void clear() {type = 0;}
9106                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9107                 template<typename V>  bool decode(V& v)
9108                 {
9109                         clear();
9110                         if(!v(ref_nested())) return false;
9111                         { type = 1; return true;}
9112                         return false;
9113
9114                 }
9115                 template<typename V> bool encode(V& v) const
9116                 {
9117                         return v(ref_nested());
9118
9119                 }
9120                 protected:
9121                 template<typename V>  bool decode(size_t index, V& v)
9122                 {
9123                         clear();
9124                         switch(index)
9125                         {
9126                         case 1: type = 1; return v(ref_nested());
9127                         ref_nested().clear();
9128                         }
9129                         return false;
9130
9131                 }
9132                 template<typename V> bool encode(size_t index, V& v) const
9133                 {
9134                         if(index != type) {return false;} return v(ref_nested());
9135
9136                 }
9137                 private:
9138                 size_t type {0};
9139
9140         };
9141         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9142         {
9143                 size_t get_index() const {return type;}
9144                 bool is_unknown() const { return type == 1; }
9145                 void clear() {type = 0;}
9146                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9147                 template<typename V>  bool decode(V& v)
9148                 {
9149                         clear();
9150                         if(!v(ref_nested())) return false;
9151                         { type = 1; return true;}
9152                         return false;
9153
9154                 }
9155                 template<typename V> bool encode(V& v) const
9156                 {
9157                         return v(ref_nested());
9158
9159                 }
9160                 protected:
9161                 template<typename V>  bool decode(size_t index, V& v)
9162                 {
9163                         clear();
9164                         switch(index)
9165                         {
9166                         case 1: type = 1; return v(ref_nested());
9167                         ref_nested().clear();
9168                         }
9169                         return false;
9170
9171                 }
9172                 template<typename V> bool encode(size_t index, V& v) const
9173                 {
9174                         if(index != type) {return false;} return v(ref_nested());
9175
9176                 }
9177                 private:
9178                 size_t type {0};
9179
9180         };
9181         struct Extension_t : asn::typefield<true>
9182         {
9183                 ~Extension_t()  {clear();}
9184                 size_t get_index() const {return type;}
9185                 bool is_unknown() const { return type == 1; }
9186                 void clear()
9187                 {
9188                         type = 0; ref_nested().clear();
9189                 }
9190                 template<typename V> static inline void enumerate(V& v)
9191                 {
9192
9193                 }
9194                 protected:
9195                 template<typename V> bool decode(size_t index, V& v)
9196                 {
9197                         clear();
9198                         switch(index)
9199                         {
9200                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9201                         }
9202                         return false;
9203
9204                 }
9205                 template<typename V> bool encode(size_t index, V& v) const
9206                 {
9207                         if(index != type) return false;
9208                         return false;
9209
9210                 }
9211                 private:
9212                 size_t type {0};
9213
9214         };
9215         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9216         {
9217                 size_t get_index() const {return type;}
9218                 bool is_unknown() const { return type == 1; }
9219                 void clear() {type = 0;}
9220                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9221                 template<typename V>  bool decode(V& v)
9222                 {
9223                         clear();
9224                         if(!v(ref_nested())) return false;
9225                         { type = 1; return true;}
9226                         return false;
9227
9228                 }
9229                 template<typename V> bool encode(V& v) const
9230                 {
9231                         return v(ref_nested());
9232
9233                 }
9234                 protected:
9235                 template<typename V>  bool decode(size_t index, V& v)
9236                 {
9237                         clear();
9238                         switch(index)
9239                         {
9240                         case 1: type = 1; return v(ref_nested());
9241                         ref_nested().clear();
9242                         }
9243                         return false;
9244
9245                 }
9246                 template<typename V> bool encode(size_t index, V& v) const
9247                 {
9248                         if(index != type) {return false;} return v(ref_nested());
9249
9250                 }
9251                 private:
9252                 size_t type {0};
9253
9254         };
9255
9256 };
9257 /*
9258 E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer ::= SEQUENCE {
9259         e-RAB-ID                                                E-RAB-ID,
9260         s1-DL-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
9261         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-SCG-BearerExtIEs} } OPTIONAL,
9262         ...
9263 }
9264 */
9265
9266 struct E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer : asn::sequence<3, 0, true, 2>
9267 {
9268         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer";}
9269         using parent_t = asn::sequence<3, 0, true, 2>;
9270         struct e_RAB_ID_t : E_RAB_ID
9271         {
9272                 static constexpr const char* name() {return "e_RAB_ID_t";}
9273                 using parent_t = E_RAB_ID;
9274
9275         };
9276         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
9277         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
9278         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
9279         {
9280                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
9281                 using parent_t = GTPtunnelEndpoint;
9282                 static constexpr bool optional = true;
9283
9284         };
9285         s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
9286         s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
9287         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>
9288         {
9289                 static constexpr const char* name() {return "iE_Extensions_t";}
9290                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_SCG_BearerExtIEs>;
9291                 static constexpr bool optional = true;
9292
9293         };
9294         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9295         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9296         template<typename V> void decode(V& v)
9297         {
9298                 v(e_RAB_ID);
9299                 v(s1_DL_GTPtunnelEndpoint);
9300                 v(iE_Extensions);
9301
9302         };
9303         template<typename V> void encode(V& v) const
9304         {
9305                 v(e_RAB_ID);
9306                 v(s1_DL_GTPtunnelEndpoint);
9307                 v(iE_Extensions);
9308
9309         };
9310         void clear()
9311         {
9312                 e_RAB_ID.clear();
9313                 s1_DL_GTPtunnelEndpoint.clear();
9314                 iE_Extensions.clear();
9315
9316         };
9317         private:
9318         e_RAB_ID_t      e_RAB_ID;
9319         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
9320         iE_Extensions_t iE_Extensions;
9321
9322 };
9323 /*
9324 E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9325         ...
9326 }
9327 */
9328
9329 struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs
9330 {
9331         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9332         {
9333                 size_t get_index() const {return type;}
9334                 bool is_unknown() const { return type == 1; }
9335                 void clear() {type = 0;}
9336                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9337                 template<typename V>  bool decode(V& v)
9338                 {
9339                         clear();
9340                         if(!v(ref_nested())) return false;
9341                         { type = 1; return true;}
9342                         return false;
9343
9344                 }
9345                 template<typename V> bool encode(V& v) const
9346                 {
9347                         return v(ref_nested());
9348
9349                 }
9350                 protected:
9351                 template<typename V>  bool decode(size_t index, V& v)
9352                 {
9353                         clear();
9354                         switch(index)
9355                         {
9356                         case 1: type = 1; return v(ref_nested());
9357                         ref_nested().clear();
9358                         }
9359                         return false;
9360
9361                 }
9362                 template<typename V> bool encode(size_t index, V& v) const
9363                 {
9364                         if(index != type) {return false;} return v(ref_nested());
9365
9366                 }
9367                 private:
9368                 size_t type {0};
9369
9370         };
9371         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9372         {
9373                 size_t get_index() const {return type;}
9374                 bool is_unknown() const { return type == 1; }
9375                 void clear() {type = 0;}
9376                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9377                 template<typename V>  bool decode(V& v)
9378                 {
9379                         clear();
9380                         if(!v(ref_nested())) return false;
9381                         { type = 1; return true;}
9382                         return false;
9383
9384                 }
9385                 template<typename V> bool encode(V& v) const
9386                 {
9387                         return v(ref_nested());
9388
9389                 }
9390                 protected:
9391                 template<typename V>  bool decode(size_t index, V& v)
9392                 {
9393                         clear();
9394                         switch(index)
9395                         {
9396                         case 1: type = 1; return v(ref_nested());
9397                         ref_nested().clear();
9398                         }
9399                         return false;
9400
9401                 }
9402                 template<typename V> bool encode(size_t index, V& v) const
9403                 {
9404                         if(index != type) {return false;} return v(ref_nested());
9405
9406                 }
9407                 private:
9408                 size_t type {0};
9409
9410         };
9411         struct Extension_t : asn::typefield<true>
9412         {
9413                 ~Extension_t()  {clear();}
9414                 size_t get_index() const {return type;}
9415                 bool is_unknown() const { return type == 1; }
9416                 void clear()
9417                 {
9418                         type = 0; ref_nested().clear();
9419                 }
9420                 template<typename V> static inline void enumerate(V& v)
9421                 {
9422
9423                 }
9424                 protected:
9425                 template<typename V> bool decode(size_t index, V& v)
9426                 {
9427                         clear();
9428                         switch(index)
9429                         {
9430                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9431                         }
9432                         return false;
9433
9434                 }
9435                 template<typename V> bool encode(size_t index, V& v) const
9436                 {
9437                         if(index != type) return false;
9438                         return false;
9439
9440                 }
9441                 private:
9442                 size_t type {0};
9443
9444         };
9445         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9446         {
9447                 size_t get_index() const {return type;}
9448                 bool is_unknown() const { return type == 1; }
9449                 void clear() {type = 0;}
9450                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9451                 template<typename V>  bool decode(V& v)
9452                 {
9453                         clear();
9454                         if(!v(ref_nested())) return false;
9455                         { type = 1; return true;}
9456                         return false;
9457
9458                 }
9459                 template<typename V> bool encode(V& v) const
9460                 {
9461                         return v(ref_nested());
9462
9463                 }
9464                 protected:
9465                 template<typename V>  bool decode(size_t index, V& v)
9466                 {
9467                         clear();
9468                         switch(index)
9469                         {
9470                         case 1: type = 1; return v(ref_nested());
9471                         ref_nested().clear();
9472                         }
9473                         return false;
9474
9475                 }
9476                 template<typename V> bool encode(size_t index, V& v) const
9477                 {
9478                         if(index != type) {return false;} return v(ref_nested());
9479
9480                 }
9481                 private:
9482                 size_t type {0};
9483
9484         };
9485
9486 };
9487 /*
9488 E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer ::= SEQUENCE {
9489         e-RAB-ID                                                E-RAB-ID,
9490         seNB-GTPtunnelEndpoint                  GTPtunnelEndpoint                                                                                                                                                       OPTIONAL,
9491         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
9492         ...
9493 }
9494 */
9495
9496 struct E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer : asn::sequence<3, 0, true, 2>
9497 {
9498         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer";}
9499         using parent_t = asn::sequence<3, 0, true, 2>;
9500         struct e_RAB_ID_t : E_RAB_ID
9501         {
9502                 static constexpr const char* name() {return "e_RAB_ID_t";}
9503                 using parent_t = E_RAB_ID;
9504
9505         };
9506         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
9507         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
9508         struct seNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
9509         {
9510                 static constexpr const char* name() {return "seNB_GTPtunnelEndpoint_t";}
9511                 using parent_t = GTPtunnelEndpoint;
9512                 static constexpr bool optional = true;
9513
9514         };
9515         seNB_GTPtunnelEndpoint_t& set_seNB_GTPtunnelEndpoint() { seNB_GTPtunnelEndpoint.setpresent(true); return seNB_GTPtunnelEndpoint;}
9516         seNB_GTPtunnelEndpoint_t const* get_seNB_GTPtunnelEndpoint() const {return seNB_GTPtunnelEndpoint.is_valid() ? &seNB_GTPtunnelEndpoint : nullptr;}
9517         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>
9518         {
9519                 static constexpr const char* name() {return "iE_Extensions_t";}
9520                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_ModAckItem_Split_BearerExtIEs>;
9521                 static constexpr bool optional = true;
9522
9523         };
9524         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9525         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9526         template<typename V> void decode(V& v)
9527         {
9528                 v(e_RAB_ID);
9529                 v(seNB_GTPtunnelEndpoint);
9530                 v(iE_Extensions);
9531
9532         };
9533         template<typename V> void encode(V& v) const
9534         {
9535                 v(e_RAB_ID);
9536                 v(seNB_GTPtunnelEndpoint);
9537                 v(iE_Extensions);
9538
9539         };
9540         void clear()
9541         {
9542                 e_RAB_ID.clear();
9543                 seNB_GTPtunnelEndpoint.clear();
9544                 iE_Extensions.clear();
9545
9546         };
9547         private:
9548         e_RAB_ID_t      e_RAB_ID;
9549         seNB_GTPtunnelEndpoint_t        seNB_GTPtunnelEndpoint;
9550         iE_Extensions_t iE_Extensions;
9551
9552 };
9553 /*
9554 E-RABs-Admitted-ToBeModified-ModAckItem ::= CHOICE {
9555         sCG-Bearer              E-RABs-Admitted-ToBeModified-ModAckItem-SCG-Bearer,
9556         split-Bearer    E-RABs-Admitted-ToBeModified-ModAckItem-Split-Bearer,
9557         ...
9558 }
9559 */
9560
9561 struct E_RABs_Admitted_ToBeModified_ModAckItem : asn::choice<2, 0, true>
9562 {
9563         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckItem";}
9564         using parent_t = asn::choice<2, 0, true>;
9565         index_type get_index() const {return index;}
9566         bool is_unknown() const {return index == 3;}
9567         void set_unknown() { set_index(3);  }
9568         ~E_RABs_Admitted_ToBeModified_ModAckItem() {clear();}
9569         struct sCG_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer
9570         {
9571                 static constexpr const char* name() {return "sCG_Bearer_t";}
9572                 using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_SCG_Bearer;
9573
9574         };
9575         struct split_Bearer_t : E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer
9576         {
9577                 static constexpr const char* name() {return "split_Bearer_t";}
9578                 using parent_t = E_RABs_Admitted_ToBeModified_ModAckItem_Split_Bearer;
9579
9580         };
9581         void clear()
9582         {
9583                 switch(get_index())
9584                 {
9585                 case 1: var.destroy<sCG_Bearer_t>(); break;
9586                 case 2: var.destroy<split_Bearer_t>(); break;
9587                 }
9588                 index = 0;
9589                 base::clear();
9590         }
9591         template<typename V> bool decode(size_t idx, V& v)
9592         {
9593                 clear();
9594                 switch(idx)
9595                 {
9596                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
9597                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
9598                 }
9599                 return false;
9600
9601         }
9602         template<typename V> bool encode(V& v) const
9603         {
9604                 switch(get_index())
9605                 {
9606                 case 1: return v(var.as<sCG_Bearer_t>());
9607                 case 2: return v(var.as<split_Bearer_t>());
9608                 }
9609                 return false;
9610         }
9611         template<typename V> static inline void enumerate(V& v)
9612         {
9613                 v.template operator()<sCG_Bearer_t>(1);
9614                 v.template operator()<split_Bearer_t>(2);
9615
9616         }
9617         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
9618         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
9619         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
9620         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
9621         private:
9622         void set_index(index_type i) {index = i; base::set();}
9623         union union_type
9624         {
9625                 char dummy1[sizeof(sCG_Bearer_t)];
9626                 char dummy2[sizeof(split_Bearer_t)];
9627
9628         };
9629         asn::variant<sizeof(union_type)>        var;
9630         index_type      index {0};
9631 };
9632 /*
9633 E-RABs-Admitted-ToBeModified-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
9634         { ID id-E-RABs-Admitted-ToBeModified-ModAckItem         CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeModified-ModAckItem    PRESENCE mandatory}
9635 }
9636 */
9637
9638 struct E_RABs_Admitted_ToBeModified_ModAckItemIEs
9639 {
9640         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
9641         {
9642                 size_t get_index() const {return type;}
9643                 void clear() {type = 0;}
9644                 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(id_E_RABs_Admitted_ToBeModified_ModAckItem); type=1;}
9645                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
9646                 template<typename V>  bool decode(V& v)
9647                 {
9648                         clear();
9649                         if(!v(ref_nested())) return false;
9650                         if(equal(id_E_RABs_Admitted_ToBeModified_ModAckItem)) { type = 1; return true; }
9651                         return false;
9652
9653                 }
9654                 template<typename V> bool encode(V& v) const
9655                 {
9656                         return v(ref_nested());
9657
9658                 }
9659                 protected:
9660                 template<typename V>  bool decode(size_t index, V& v)
9661                 {
9662                         clear();
9663                         switch(index)
9664                         {
9665                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_ModAckItem);} return false;
9666                         ref_nested().clear();
9667                         }
9668                         return false;
9669
9670                 }
9671                 template<typename V> bool encode(size_t index, V& v) const
9672                 {
9673                         if(index != type) {return false;} return v(ref_nested());
9674
9675                 }
9676                 private:
9677                 size_t type {0};
9678
9679         };
9680         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
9681         {
9682                 size_t get_index() const {return type;}
9683                 void clear() {type = 0;}
9684                 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(ignore); type=1;}
9685                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
9686                 template<typename V>  bool decode(V& v)
9687                 {
9688                         clear();
9689                         if(!v(ref_nested())) return false;
9690                         if(equal(ignore)) { type = 1; return true; }
9691                         return false;
9692
9693                 }
9694                 template<typename V> bool encode(V& v) const
9695                 {
9696                         return v(ref_nested());
9697
9698                 }
9699                 protected:
9700                 template<typename V>  bool decode(size_t index, V& v)
9701                 {
9702                         clear();
9703                         switch(index)
9704                         {
9705                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
9706                         ref_nested().clear();
9707                         }
9708                         return false;
9709
9710                 }
9711                 template<typename V> bool encode(size_t index, V& v) const
9712                 {
9713                         if(index != type) {return false;} return v(ref_nested());
9714
9715                 }
9716                 private:
9717                 size_t type {0};
9718
9719         };
9720         struct Value_t : asn::typefield<false>
9721         {
9722                 ~Value_t()      {clear();}
9723                 size_t get_index() const {return type;}
9724                 E_RABs_Admitted_ToBeModified_ModAckItem& select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { return set<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
9725                 E_RABs_Admitted_ToBeModified_ModAckItem const* get_id_E_RABs_Admitted_ToBeModified_ModAckItem() const { return get<E_RABs_Admitted_ToBeModified_ModAckItem>(1); }
9726                 void clear()
9727                 {
9728                         switch(type)
9729                         {
9730                         case 1: var.destroy<E_RABs_Admitted_ToBeModified_ModAckItem>(); break;
9731                         }
9732                         type = 0; ref_nested().clear();
9733                 }
9734                 template<typename V> static inline void enumerate(V& v)
9735                 {
9736                         v.template operator()<E_RABs_Admitted_ToBeModified_ModAckItem>(1);
9737
9738                 }
9739                 protected:
9740                 template<typename V> bool decode(size_t index, V& v)
9741                 {
9742                         clear();
9743                         switch(index)
9744                         {
9745                         case 1: v(select_id_E_RABs_Admitted_ToBeModified_ModAckItem()); return true;
9746                         }
9747                         return false;
9748
9749                 }
9750                 template<typename V> bool encode(size_t index, V& v) const
9751                 {
9752                         if(index != type) return false;
9753                         switch(type)
9754                         {
9755                         case 1: v(var.as<E_RABs_Admitted_ToBeModified_ModAckItem>()); return true;
9756                         }
9757                         return false;
9758
9759                 }
9760                 private:
9761                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9762                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9763                 union union_type
9764                 {
9765                         char dummy1[sizeof(E_RABs_Admitted_ToBeModified_ModAckItem)];
9766
9767                 };
9768                 asn::variant<sizeof(union_type)> var;
9769                 size_t type {0};
9770
9771         };
9772         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
9773         {
9774                 size_t get_index() const {return type;}
9775                 void clear() {type = 0;}
9776                 void select_id_E_RABs_Admitted_ToBeModified_ModAckItem() { set(mandatory); type=1;}
9777                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
9778                 template<typename V>  bool decode(V& v)
9779                 {
9780                         clear();
9781                         if(!v(ref_nested())) return false;
9782                         if(equal(mandatory)) { type = 1; return true; }
9783                         return false;
9784
9785                 }
9786                 template<typename V> bool encode(V& v) const
9787                 {
9788                         return v(ref_nested());
9789
9790                 }
9791                 protected:
9792                 template<typename V>  bool decode(size_t index, V& v)
9793                 {
9794                         clear();
9795                         switch(index)
9796                         {
9797                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
9798                         ref_nested().clear();
9799                         }
9800                         return false;
9801
9802                 }
9803                 template<typename V> bool encode(size_t index, V& v) const
9804                 {
9805                         if(index != type) {return false;} return v(ref_nested());
9806
9807                 }
9808                 private:
9809                 size_t type {0};
9810
9811         };
9812
9813 };
9814 /*
9815 E-RABs-Admitted-ToBeModified-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-ModAckItemIEs} }
9816 */
9817
9818 struct E_RABs_Admitted_ToBeModified_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>
9819 {
9820         static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_ModAckList_elm";}
9821         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_ModAckItemIEs>;
9822
9823 };
9824 struct E_RABs_Admitted_ToBeModified_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>
9825 {
9826         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-ModAckList";}
9827         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_ModAckList_elm>;
9828         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
9829
9830 };
9831 /*
9832 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9833         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
9834         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional},
9835         ...
9836 }
9837 */
9838
9839 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs
9840 {
9841         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9842         {
9843                 size_t get_index() const {return type;}
9844                 bool is_unknown() const { return type == 3; }
9845                 void clear() {type = 0;}
9846                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
9847                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
9848                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9849                 template<typename V>  bool decode(V& v)
9850                 {
9851                         clear();
9852                         if(!v(ref_nested())) return false;
9853                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
9854                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
9855                         else { type = 3; return true;}
9856                         return false;
9857
9858                 }
9859                 template<typename V> bool encode(V& v) const
9860                 {
9861                         return v(ref_nested());
9862
9863                 }
9864                 protected:
9865                 template<typename V>  bool decode(size_t index, V& v)
9866                 {
9867                         clear();
9868                         switch(index)
9869                         {
9870                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
9871                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
9872                         case 3: type = 3; return v(ref_nested());
9873                         ref_nested().clear();
9874                         }
9875                         return false;
9876
9877                 }
9878                 template<typename V> bool encode(size_t index, V& v) const
9879                 {
9880                         if(index != type) {return false;} return v(ref_nested());
9881
9882                 }
9883                 private:
9884                 size_t type {0};
9885
9886         };
9887         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9888         {
9889                 size_t get_index() const {return type;}
9890                 bool is_unknown() const { return type == 3; }
9891                 void clear() {type = 0;}
9892                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
9893                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
9894                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9895                 template<typename V>  bool decode(V& v)
9896                 {
9897                         clear();
9898                         if(!v(ref_nested())) return false;
9899                         if(equal(ignore)) { type = 1; return true; }
9900                         else if(equal(ignore)) { type = 2; return true; }
9901                         else { type = 3; return true;}
9902                         return false;
9903
9904                 }
9905                 template<typename V> bool encode(V& v) const
9906                 {
9907                         return v(ref_nested());
9908
9909                 }
9910                 protected:
9911                 template<typename V>  bool decode(size_t index, V& v)
9912                 {
9913                         clear();
9914                         switch(index)
9915                         {
9916                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
9917                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
9918                         case 3: type = 3; return v(ref_nested());
9919                         ref_nested().clear();
9920                         }
9921                         return false;
9922
9923                 }
9924                 template<typename V> bool encode(size_t index, V& v) const
9925                 {
9926                         if(index != type) {return false;} return v(ref_nested());
9927
9928                 }
9929                 private:
9930                 size_t type {0};
9931
9932         };
9933         struct Extension_t : asn::typefield<true>
9934         {
9935                 ~Extension_t()  {clear();}
9936                 size_t get_index() const {return type;}
9937                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
9938                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
9939                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
9940                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
9941                 bool is_unknown() const { return type == 3; }
9942                 void clear()
9943                 {
9944                         switch(type)
9945                         {
9946                         case 1: var.destroy<PDCPSnLength>(); break;
9947                         case 2: var.destroy<PDCPSnLength>(); break;
9948                         }
9949                         type = 0; ref_nested().clear();
9950                 }
9951                 template<typename V> static inline void enumerate(V& v)
9952                 {
9953                         v.template operator()<PDCPSnLength>(1);
9954                         v.template operator()<PDCPSnLength>(2);
9955
9956                 }
9957                 protected:
9958                 template<typename V> bool decode(size_t index, V& v)
9959                 {
9960                         clear();
9961                         switch(index)
9962                         {
9963                         case 1: v(select_id_uLpDCPSnLength()); return true;
9964                         case 2: v(select_id_dLPDCPSnLength()); return true;
9965                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
9966                         }
9967                         return false;
9968
9969                 }
9970                 template<typename V> bool encode(size_t index, V& v) const
9971                 {
9972                         if(index != type) return false;
9973                         switch(type)
9974                         {
9975                         case 1: v(var.as<PDCPSnLength>()); return true;
9976                         case 2: v(var.as<PDCPSnLength>()); return true;
9977                         }
9978                         return false;
9979
9980                 }
9981                 private:
9982                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
9983                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
9984                 union union_type
9985                 {
9986                         char dummy1[sizeof(PDCPSnLength)];
9987
9988                 };
9989                 asn::variant<sizeof(union_type)> var;
9990                 size_t type {0};
9991
9992         };
9993         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9994         {
9995                 size_t get_index() const {return type;}
9996                 bool is_unknown() const { return type == 3; }
9997                 void clear() {type = 0;}
9998                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
9999                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
10000                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10001                 template<typename V>  bool decode(V& v)
10002                 {
10003                         clear();
10004                         if(!v(ref_nested())) return false;
10005                         if(equal(optional)) { type = 1; return true; }
10006                         else if(equal(optional)) { type = 2; return true; }
10007                         else { type = 3; return true;}
10008                         return false;
10009
10010                 }
10011                 template<typename V> bool encode(V& v) const
10012                 {
10013                         return v(ref_nested());
10014
10015                 }
10016                 protected:
10017                 template<typename V>  bool decode(size_t index, V& v)
10018                 {
10019                         clear();
10020                         switch(index)
10021                         {
10022                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
10023                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
10024                         case 3: type = 3; return v(ref_nested());
10025                         ref_nested().clear();
10026                         }
10027                         return false;
10028
10029                 }
10030                 template<typename V> bool encode(size_t index, V& v) const
10031                 {
10032                         if(index != type) {return false;} return v(ref_nested());
10033
10034                 }
10035                 private:
10036                 size_t type {0};
10037
10038         };
10039
10040 };
10041 /*
10042 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
10043         s1-DL-GTPtunnelEndpoint                                 GTPtunnelEndpoint                                                                                                                                                                               OPTIONAL,
10044         sgNB-UL-GTP-TEIDatPDCP                                  GTPtunnelEndpoint                                                                                                                                                                               OPTIONAL,
10045         mCG-E-RAB-Level-QoS-Parameters                  E-RAB-Level-QoS-Parameters                                                                                                                                                              OPTIONAL,
10046         uL-Configuration                                                        ULConfiguration                                                                                                                                                                                 OPTIONAL,
10047         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresentExtIEs} }     OPTIONAL,
10048         ...
10049 }
10050 */
10051
10052 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
10053 {
10054         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent";}
10055         using parent_t = asn::sequence<5, 0, true, 5>;
10056         struct s1_DL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
10057         {
10058                 static constexpr const char* name() {return "s1_DL_GTPtunnelEndpoint_t";}
10059                 using parent_t = GTPtunnelEndpoint;
10060                 static constexpr bool optional = true;
10061
10062         };
10063         s1_DL_GTPtunnelEndpoint_t& set_s1_DL_GTPtunnelEndpoint() { s1_DL_GTPtunnelEndpoint.setpresent(true); return s1_DL_GTPtunnelEndpoint;}
10064         s1_DL_GTPtunnelEndpoint_t const* get_s1_DL_GTPtunnelEndpoint() const {return s1_DL_GTPtunnelEndpoint.is_valid() ? &s1_DL_GTPtunnelEndpoint : nullptr;}
10065         struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
10066         {
10067                 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
10068                 using parent_t = GTPtunnelEndpoint;
10069                 static constexpr bool optional = true;
10070
10071         };
10072         sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
10073         sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
10074         struct mCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
10075         {
10076                 static constexpr const char* name() {return "mCG_E_RAB_Level_QoS_Parameters_t";}
10077                 using parent_t = E_RAB_Level_QoS_Parameters;
10078                 static constexpr bool optional = true;
10079
10080         };
10081         mCG_E_RAB_Level_QoS_Parameters_t& set_mCG_E_RAB_Level_QoS_Parameters() { mCG_E_RAB_Level_QoS_Parameters.setpresent(true); return mCG_E_RAB_Level_QoS_Parameters;}
10082         mCG_E_RAB_Level_QoS_Parameters_t const* get_mCG_E_RAB_Level_QoS_Parameters() const {return mCG_E_RAB_Level_QoS_Parameters.is_valid() ? &mCG_E_RAB_Level_QoS_Parameters : nullptr;}
10083         struct uL_Configuration_t : ULConfiguration
10084         {
10085                 static constexpr const char* name() {return "uL_Configuration_t";}
10086                 using parent_t = ULConfiguration;
10087                 static constexpr bool optional = true;
10088
10089         };
10090         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
10091         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
10092         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
10093         {
10094                 static constexpr const char* name() {return "iE_Extensions_t";}
10095                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
10096                 static constexpr bool optional = true;
10097
10098         };
10099         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10100         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10101         template<typename V> void decode(V& v)
10102         {
10103                 v(s1_DL_GTPtunnelEndpoint);
10104                 v(sgNB_UL_GTP_TEIDatPDCP);
10105                 v(mCG_E_RAB_Level_QoS_Parameters);
10106                 v(uL_Configuration);
10107                 v(iE_Extensions);
10108
10109         };
10110         template<typename V> void encode(V& v) const
10111         {
10112                 v(s1_DL_GTPtunnelEndpoint);
10113                 v(sgNB_UL_GTP_TEIDatPDCP);
10114                 v(mCG_E_RAB_Level_QoS_Parameters);
10115                 v(uL_Configuration);
10116                 v(iE_Extensions);
10117
10118         };
10119         void clear()
10120         {
10121                 s1_DL_GTPtunnelEndpoint.clear();
10122                 sgNB_UL_GTP_TEIDatPDCP.clear();
10123                 mCG_E_RAB_Level_QoS_Parameters.clear();
10124                 uL_Configuration.clear();
10125                 iE_Extensions.clear();
10126
10127         };
10128         private:
10129         s1_DL_GTPtunnelEndpoint_t       s1_DL_GTPtunnelEndpoint;
10130         sgNB_UL_GTP_TEIDatPDCP_t        sgNB_UL_GTP_TEIDatPDCP;
10131         mCG_E_RAB_Level_QoS_Parameters_t        mCG_E_RAB_Level_QoS_Parameters;
10132         uL_Configuration_t      uL_Configuration;
10133         iE_Extensions_t iE_Extensions;
10134
10135 };
10136 /*
10137 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10138         { ID id-secondarysgNBDLGTPTEIDatPDCP                    CRITICALITY ignore      EXTENSION GTPtunnelEndpoint                             PRESENCE optional}|
10139         { ID id-RLC-Status                                                              CRITICALITY ignore                      EXTENSION RLC-Status                            PRESENCE optional },
10140         ...
10141 }
10142 */
10143
10144 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
10145 {
10146         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10147         {
10148                 size_t get_index() const {return type;}
10149                 bool is_unknown() const { return type == 3; }
10150                 void clear() {type = 0;}
10151                 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(id_secondarysgNBDLGTPTEIDatPDCP); type=1;}
10152                 void select_id_RLC_Status() { set(id_RLC_Status); type=2;}
10153                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10154                 template<typename V>  bool decode(V& v)
10155                 {
10156                         clear();
10157                         if(!v(ref_nested())) return false;
10158                         if(equal(id_secondarysgNBDLGTPTEIDatPDCP)) { type = 1; return true; }
10159                         else if(equal(id_RLC_Status)) { type = 2; return true; }
10160                         else { type = 3; return true;}
10161                         return false;
10162
10163                 }
10164                 template<typename V> bool encode(V& v) const
10165                 {
10166                         return v(ref_nested());
10167
10168                 }
10169                 protected:
10170                 template<typename V>  bool decode(size_t index, V& v)
10171                 {
10172                         clear();
10173                         switch(index)
10174                         {
10175                         case 1: type = 1; if(v(ref_nested())) { return equal(id_secondarysgNBDLGTPTEIDatPDCP);} return false;
10176                         case 2: type = 2; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
10177                         case 3: type = 3; return v(ref_nested());
10178                         ref_nested().clear();
10179                         }
10180                         return false;
10181
10182                 }
10183                 template<typename V> bool encode(size_t index, V& v) const
10184                 {
10185                         if(index != type) {return false;} return v(ref_nested());
10186
10187                 }
10188                 private:
10189                 size_t type {0};
10190
10191         };
10192         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10193         {
10194                 size_t get_index() const {return type;}
10195                 bool is_unknown() const { return type == 3; }
10196                 void clear() {type = 0;}
10197                 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(ignore); type=1;}
10198                 void select_id_RLC_Status() { set(ignore); type=2;}
10199                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10200                 template<typename V>  bool decode(V& v)
10201                 {
10202                         clear();
10203                         if(!v(ref_nested())) return false;
10204                         if(equal(ignore)) { type = 1; return true; }
10205                         else if(equal(ignore)) { type = 2; return true; }
10206                         else { type = 3; return true;}
10207                         return false;
10208
10209                 }
10210                 template<typename V> bool encode(V& v) const
10211                 {
10212                         return v(ref_nested());
10213
10214                 }
10215                 protected:
10216                 template<typename V>  bool decode(size_t index, V& v)
10217                 {
10218                         clear();
10219                         switch(index)
10220                         {
10221                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
10222                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
10223                         case 3: type = 3; return v(ref_nested());
10224                         ref_nested().clear();
10225                         }
10226                         return false;
10227
10228                 }
10229                 template<typename V> bool encode(size_t index, V& v) const
10230                 {
10231                         if(index != type) {return false;} return v(ref_nested());
10232
10233                 }
10234                 private:
10235                 size_t type {0};
10236
10237         };
10238         struct Extension_t : asn::typefield<true>
10239         {
10240                 ~Extension_t()  {clear();}
10241                 size_t get_index() const {return type;}
10242                 GTPtunnelEndpoint& select_id_secondarysgNBDLGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(1); }
10243                 GTPtunnelEndpoint const* get_id_secondarysgNBDLGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(1); }
10244                 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(2); }
10245                 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(2); }
10246                 bool is_unknown() const { return type == 3; }
10247                 void clear()
10248                 {
10249                         switch(type)
10250                         {
10251                         case 1: var.destroy<GTPtunnelEndpoint>(); break;
10252                         case 2: var.destroy<RLC_Status>(); break;
10253                         }
10254                         type = 0; ref_nested().clear();
10255                 }
10256                 template<typename V> static inline void enumerate(V& v)
10257                 {
10258                         v.template operator()<GTPtunnelEndpoint>(1);
10259                         v.template operator()<RLC_Status>(2);
10260
10261                 }
10262                 protected:
10263                 template<typename V> bool decode(size_t index, V& v)
10264                 {
10265                         clear();
10266                         switch(index)
10267                         {
10268                         case 1: v(select_id_secondarysgNBDLGTPTEIDatPDCP()); return true;
10269                         case 2: v(select_id_RLC_Status()); return true;
10270                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
10271                         }
10272                         return false;
10273
10274                 }
10275                 template<typename V> bool encode(size_t index, V& v) const
10276                 {
10277                         if(index != type) return false;
10278                         switch(type)
10279                         {
10280                         case 1: v(var.as<GTPtunnelEndpoint>()); return true;
10281                         case 2: v(var.as<RLC_Status>()); return true;
10282                         }
10283                         return false;
10284
10285                 }
10286                 private:
10287                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
10288                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
10289                 union union_type
10290                 {
10291                         char dummy1[sizeof(GTPtunnelEndpoint)];
10292                         char dummy2[sizeof(RLC_Status)];
10293
10294                 };
10295                 asn::variant<sizeof(union_type)> var;
10296                 size_t type {0};
10297
10298         };
10299         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10300         {
10301                 size_t get_index() const {return type;}
10302                 bool is_unknown() const { return type == 3; }
10303                 void clear() {type = 0;}
10304                 void select_id_secondarysgNBDLGTPTEIDatPDCP() { set(optional); type=1;}
10305                 void select_id_RLC_Status() { set(optional); type=2;}
10306                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10307                 template<typename V>  bool decode(V& v)
10308                 {
10309                         clear();
10310                         if(!v(ref_nested())) return false;
10311                         if(equal(optional)) { type = 1; return true; }
10312                         else if(equal(optional)) { type = 2; return true; }
10313                         else { type = 3; return true;}
10314                         return false;
10315
10316                 }
10317                 template<typename V> bool encode(V& v) const
10318                 {
10319                         return v(ref_nested());
10320
10321                 }
10322                 protected:
10323                 template<typename V>  bool decode(size_t index, V& v)
10324                 {
10325                         clear();
10326                         switch(index)
10327                         {
10328                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
10329                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
10330                         case 3: type = 3; return v(ref_nested());
10331                         ref_nested().clear();
10332                         }
10333                         return false;
10334
10335                 }
10336                 template<typename V> bool encode(size_t index, V& v) const
10337                 {
10338                         if(index != type) {return false;} return v(ref_nested());
10339
10340                 }
10341                 private:
10342                 size_t type {0};
10343
10344         };
10345
10346 };
10347 /*
10348 E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
10349         sgNB-DL-GTP-TEIDatSCG                                   GTPtunnelEndpoint                                                                                                                                                                                               OPTIONAL,
10350         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} }  OPTIONAL,
10351         ...
10352 }
10353 */
10354
10355 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
10356 {
10357         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent";}
10358         using parent_t = asn::sequence<2, 0, true, 2>;
10359         struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
10360         {
10361                 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
10362                 using parent_t = GTPtunnelEndpoint;
10363                 static constexpr bool optional = true;
10364
10365         };
10366         sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
10367         sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
10368         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
10369         {
10370                 static constexpr const char* name() {return "iE_Extensions_t";}
10371                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
10372                 static constexpr bool optional = true;
10373
10374         };
10375         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10376         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10377         template<typename V> void decode(V& v)
10378         {
10379                 v(sgNB_DL_GTP_TEIDatSCG);
10380                 v(iE_Extensions);
10381
10382         };
10383         template<typename V> void encode(V& v) const
10384         {
10385                 v(sgNB_DL_GTP_TEIDatSCG);
10386                 v(iE_Extensions);
10387
10388         };
10389         void clear()
10390         {
10391                 sgNB_DL_GTP_TEIDatSCG.clear();
10392                 iE_Extensions.clear();
10393
10394         };
10395         private:
10396         sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
10397         iE_Extensions_t iE_Extensions;
10398
10399 };
10400 /*
10401 E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10402         ...
10403 }
10404 */
10405
10406 struct E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs
10407 {
10408         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10409         {
10410                 size_t get_index() const {return type;}
10411                 bool is_unknown() const { return type == 1; }
10412                 void clear() {type = 0;}
10413                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10414                 template<typename V>  bool decode(V& v)
10415                 {
10416                         clear();
10417                         if(!v(ref_nested())) return false;
10418                         { type = 1; return true;}
10419                         return false;
10420
10421                 }
10422                 template<typename V> bool encode(V& v) const
10423                 {
10424                         return v(ref_nested());
10425
10426                 }
10427                 protected:
10428                 template<typename V>  bool decode(size_t index, V& v)
10429                 {
10430                         clear();
10431                         switch(index)
10432                         {
10433                         case 1: type = 1; return v(ref_nested());
10434                         ref_nested().clear();
10435                         }
10436                         return false;
10437
10438                 }
10439                 template<typename V> bool encode(size_t index, V& v) const
10440                 {
10441                         if(index != type) {return false;} return v(ref_nested());
10442
10443                 }
10444                 private:
10445                 size_t type {0};
10446
10447         };
10448         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10449         {
10450                 size_t get_index() const {return type;}
10451                 bool is_unknown() const { return type == 1; }
10452                 void clear() {type = 0;}
10453                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10454                 template<typename V>  bool decode(V& v)
10455                 {
10456                         clear();
10457                         if(!v(ref_nested())) return false;
10458                         { type = 1; return true;}
10459                         return false;
10460
10461                 }
10462                 template<typename V> bool encode(V& v) const
10463                 {
10464                         return v(ref_nested());
10465
10466                 }
10467                 protected:
10468                 template<typename V>  bool decode(size_t index, V& v)
10469                 {
10470                         clear();
10471                         switch(index)
10472                         {
10473                         case 1: type = 1; return v(ref_nested());
10474                         ref_nested().clear();
10475                         }
10476                         return false;
10477
10478                 }
10479                 template<typename V> bool encode(size_t index, V& v) const
10480                 {
10481                         if(index != type) {return false;} return v(ref_nested());
10482
10483                 }
10484                 private:
10485                 size_t type {0};
10486
10487         };
10488         struct Extension_t : asn::typefield<true>
10489         {
10490                 ~Extension_t()  {clear();}
10491                 size_t get_index() const {return type;}
10492                 bool is_unknown() const { return type == 1; }
10493                 void clear()
10494                 {
10495                         type = 0; ref_nested().clear();
10496                 }
10497                 template<typename V> static inline void enumerate(V& v)
10498                 {
10499
10500                 }
10501                 protected:
10502                 template<typename V> bool decode(size_t index, V& v)
10503                 {
10504                         clear();
10505                         switch(index)
10506                         {
10507                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10508                         }
10509                         return false;
10510
10511                 }
10512                 template<typename V> bool encode(size_t index, V& v) const
10513                 {
10514                         if(index != type) return false;
10515                         return false;
10516
10517                 }
10518                 private:
10519                 size_t type {0};
10520
10521         };
10522         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10523         {
10524                 size_t get_index() const {return type;}
10525                 bool is_unknown() const { return type == 1; }
10526                 void clear() {type = 0;}
10527                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10528                 template<typename V>  bool decode(V& v)
10529                 {
10530                         clear();
10531                         if(!v(ref_nested())) return false;
10532                         { type = 1; return true;}
10533                         return false;
10534
10535                 }
10536                 template<typename V> bool encode(V& v) const
10537                 {
10538                         return v(ref_nested());
10539
10540                 }
10541                 protected:
10542                 template<typename V>  bool decode(size_t index, V& v)
10543                 {
10544                         clear();
10545                         switch(index)
10546                         {
10547                         case 1: type = 1; return v(ref_nested());
10548                         ref_nested().clear();
10549                         }
10550                         return false;
10551
10552                 }
10553                 template<typename V> bool encode(size_t index, V& v) const
10554                 {
10555                         if(index != type) {return false;} return v(ref_nested());
10556
10557                 }
10558                 private:
10559                 size_t type {0};
10560
10561         };
10562
10563 };
10564 /*
10565 E-RABs-Admitted-ToBeModified-SgNBModAck-Item ::= SEQUENCE {
10566         e-RAB-ID                                                                E-RAB-ID,
10567         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
10568         resource-configuration                          CHOICE {
10569                 sgNBPDCPpresent                                         E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPpresent,
10570                 sgNBPDCPnotpresent                                      E-RABs-Admitted-ToBeModified-SgNBModAck-Item-SgNBPDCPnotpresent,
10571                 ...
10572         },
10573         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModAck-ItemExtIEs} } OPTIONAL,
10574         ...
10575 }
10576 */
10577
10578 struct E_RABs_Admitted_ToBeModified_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
10579 {
10580         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAck-Item";}
10581         using parent_t = asn::sequence<4, 0, true, 1>;
10582         struct e_RAB_ID_t : E_RAB_ID
10583         {
10584                 static constexpr const char* name() {return "e_RAB_ID_t";}
10585                 using parent_t = E_RAB_ID;
10586
10587         };
10588         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
10589         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
10590         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
10591         {
10592                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
10593                 using parent_t = EN_DC_ResourceConfiguration;
10594
10595         };
10596         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
10597         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
10598         struct resource_configuration_t : asn::choice<2, 0, true>
10599         {
10600                 static constexpr const char* name() {return "resource_configuration_t";}
10601                 using parent_t = asn::choice<2, 0, true>;
10602                 index_type get_index() const {return index;}
10603                 bool is_unknown() const {return index == 3;}
10604                 void set_unknown() { set_index(3);  }
10605                 ~resource_configuration_t() {clear();}
10606                 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent
10607                 {
10608                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
10609                         using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPpresent;
10610
10611                 };
10612                 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent
10613                 {
10614                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
10615                         using parent_t = E_RABs_Admitted_ToBeModified_SgNBModAck_Item_SgNBPDCPnotpresent;
10616
10617                 };
10618                 void clear()
10619                 {
10620                         switch(get_index())
10621                         {
10622                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
10623                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
10624                         }
10625                         index = 0;
10626                         base::clear();
10627                 }
10628                 template<typename V> bool decode(size_t idx, V& v)
10629                 {
10630                         clear();
10631                         switch(idx)
10632                         {
10633                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
10634                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
10635                         }
10636                         return false;
10637
10638                 }
10639                 template<typename V> bool encode(V& v) const
10640                 {
10641                         switch(get_index())
10642                         {
10643                         case 1: return v(var.as<sgNBPDCPpresent_t>());
10644                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
10645                         }
10646                         return false;
10647                 }
10648                 template<typename V> static inline void enumerate(V& v)
10649                 {
10650                         v.template operator()<sgNBPDCPpresent_t>(1);
10651                         v.template operator()<sgNBPDCPnotpresent_t>(2);
10652
10653                 }
10654                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
10655                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
10656                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
10657                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
10658                 private:
10659                 void set_index(index_type i) {index = i; base::set();}
10660                 union union_type
10661                 {
10662                         char dummy1[sizeof(sgNBPDCPpresent_t)];
10663                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
10664
10665                 };
10666                 asn::variant<sizeof(union_type)>        var;
10667                 index_type      index {0};
10668         };
10669         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
10670         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
10671         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>
10672         {
10673                 static constexpr const char* name() {return "iE_Extensions_t";}
10674                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModAck_ItemExtIEs>;
10675                 static constexpr bool optional = true;
10676
10677         };
10678         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10679         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10680         template<typename V> void decode(V& v)
10681         {
10682                 v(e_RAB_ID);
10683                 v(en_DC_ResourceConfiguration);
10684                 v(resource_configuration);
10685                 v(iE_Extensions);
10686
10687         };
10688         template<typename V> void encode(V& v) const
10689         {
10690                 v(e_RAB_ID);
10691                 v(en_DC_ResourceConfiguration);
10692                 v(resource_configuration);
10693                 v(iE_Extensions);
10694
10695         };
10696         void clear()
10697         {
10698                 e_RAB_ID.clear();
10699                 en_DC_ResourceConfiguration.clear();
10700                 resource_configuration.clear();
10701                 iE_Extensions.clear();
10702
10703         };
10704         private:
10705         e_RAB_ID_t      e_RAB_ID;
10706         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
10707         resource_configuration_t        resource_configuration;
10708         iE_Extensions_t iE_Extensions;
10709
10710 };
10711 /*
10712 E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
10713         { ID id-E-RABs-Admitted-ToBeModified-SgNBModAck-Item            CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeModified-SgNBModAck-Item               PRESENCE mandatory}
10714 }
10715 */
10716
10717 struct E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs
10718 {
10719         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
10720         {
10721                 size_t get_index() const {return type;}
10722                 void clear() {type = 0;}
10723                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item); type=1;}
10724                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
10725                 template<typename V>  bool decode(V& v)
10726                 {
10727                         clear();
10728                         if(!v(ref_nested())) return false;
10729                         if(equal(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item)) { type = 1; return true; }
10730                         return false;
10731
10732                 }
10733                 template<typename V> bool encode(V& v) const
10734                 {
10735                         return v(ref_nested());
10736
10737                 }
10738                 protected:
10739                 template<typename V>  bool decode(size_t index, V& v)
10740                 {
10741                         clear();
10742                         switch(index)
10743                         {
10744                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item);} return false;
10745                         ref_nested().clear();
10746                         }
10747                         return false;
10748
10749                 }
10750                 template<typename V> bool encode(size_t index, V& v) const
10751                 {
10752                         if(index != type) {return false;} return v(ref_nested());
10753
10754                 }
10755                 private:
10756                 size_t type {0};
10757
10758         };
10759         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
10760         {
10761                 size_t get_index() const {return type;}
10762                 void clear() {type = 0;}
10763                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(ignore); type=1;}
10764                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
10765                 template<typename V>  bool decode(V& v)
10766                 {
10767                         clear();
10768                         if(!v(ref_nested())) return false;
10769                         if(equal(ignore)) { type = 1; return true; }
10770                         return false;
10771
10772                 }
10773                 template<typename V> bool encode(V& v) const
10774                 {
10775                         return v(ref_nested());
10776
10777                 }
10778                 protected:
10779                 template<typename V>  bool decode(size_t index, V& v)
10780                 {
10781                         clear();
10782                         switch(index)
10783                         {
10784                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
10785                         ref_nested().clear();
10786                         }
10787                         return false;
10788
10789                 }
10790                 template<typename V> bool encode(size_t index, V& v) const
10791                 {
10792                         if(index != type) {return false;} return v(ref_nested());
10793
10794                 }
10795                 private:
10796                 size_t type {0};
10797
10798         };
10799         struct Value_t : asn::typefield<false>
10800         {
10801                 ~Value_t()      {clear();}
10802                 size_t get_index() const {return type;}
10803                 E_RABs_Admitted_ToBeModified_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { return set<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
10804                 E_RABs_Admitted_ToBeModified_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1); }
10805                 void clear()
10806                 {
10807                         switch(type)
10808                         {
10809                         case 1: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(); break;
10810                         }
10811                         type = 0; ref_nested().clear();
10812                 }
10813                 template<typename V> static inline void enumerate(V& v)
10814                 {
10815                         v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>(1);
10816
10817                 }
10818                 protected:
10819                 template<typename V> bool decode(size_t index, V& v)
10820                 {
10821                         clear();
10822                         switch(index)
10823                         {
10824                         case 1: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item()); return true;
10825                         }
10826                         return false;
10827
10828                 }
10829                 template<typename V> bool encode(size_t index, V& v) const
10830                 {
10831                         if(index != type) return false;
10832                         switch(type)
10833                         {
10834                         case 1: v(var.as<E_RABs_Admitted_ToBeModified_SgNBModAck_Item>()); return true;
10835                         }
10836                         return false;
10837
10838                 }
10839                 private:
10840                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
10841                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
10842                 union union_type
10843                 {
10844                         char dummy1[sizeof(E_RABs_Admitted_ToBeModified_SgNBModAck_Item)];
10845
10846                 };
10847                 asn::variant<sizeof(union_type)> var;
10848                 size_t type {0};
10849
10850         };
10851         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
10852         {
10853                 size_t get_index() const {return type;}
10854                 void clear() {type = 0;}
10855                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAck_Item() { set(mandatory); type=1;}
10856                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
10857                 template<typename V>  bool decode(V& v)
10858                 {
10859                         clear();
10860                         if(!v(ref_nested())) return false;
10861                         if(equal(mandatory)) { type = 1; return true; }
10862                         return false;
10863
10864                 }
10865                 template<typename V> bool encode(V& v) const
10866                 {
10867                         return v(ref_nested());
10868
10869                 }
10870                 protected:
10871                 template<typename V>  bool decode(size_t index, V& v)
10872                 {
10873                         clear();
10874                         switch(index)
10875                         {
10876                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
10877                         ref_nested().clear();
10878                         }
10879                         return false;
10880
10881                 }
10882                 template<typename V> bool encode(size_t index, V& v) const
10883                 {
10884                         if(index != type) {return false;} return v(ref_nested());
10885
10886                 }
10887                 private:
10888                 size_t type {0};
10889
10890         };
10891
10892 };
10893 /*
10894 E-RABs-Admitted-ToBeModified-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeModified-SgNBModAck-ItemIEs} }
10895 */
10896
10897 struct E_RABs_Admitted_ToBeModified_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>
10898 {
10899         static constexpr const char* name() {return "E_RABs_Admitted_ToBeModified_SgNBModAckList_elm";}
10900         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeModified_SgNBModAck_ItemIEs>;
10901
10902 };
10903 struct E_RABs_Admitted_ToBeModified_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>
10904 {
10905         static constexpr const char* name() {return "E-RABs-Admitted-ToBeModified-SgNBModAckList";}
10906         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeModified_SgNBModAckList_elm>;
10907         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
10908
10909 };
10910 /*
10911 E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10912         ...
10913 }
10914 */
10915
10916 struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs
10917 {
10918         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10919         {
10920                 size_t get_index() const {return type;}
10921                 bool is_unknown() const { return type == 1; }
10922                 void clear() {type = 0;}
10923                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10924                 template<typename V>  bool decode(V& v)
10925                 {
10926                         clear();
10927                         if(!v(ref_nested())) return false;
10928                         { type = 1; return true;}
10929                         return false;
10930
10931                 }
10932                 template<typename V> bool encode(V& v) const
10933                 {
10934                         return v(ref_nested());
10935
10936                 }
10937                 protected:
10938                 template<typename V>  bool decode(size_t index, V& v)
10939                 {
10940                         clear();
10941                         switch(index)
10942                         {
10943                         case 1: type = 1; return v(ref_nested());
10944                         ref_nested().clear();
10945                         }
10946                         return false;
10947
10948                 }
10949                 template<typename V> bool encode(size_t index, V& v) const
10950                 {
10951                         if(index != type) {return false;} return v(ref_nested());
10952
10953                 }
10954                 private:
10955                 size_t type {0};
10956
10957         };
10958         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10959         {
10960                 size_t get_index() const {return type;}
10961                 bool is_unknown() const { return type == 1; }
10962                 void clear() {type = 0;}
10963                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10964                 template<typename V>  bool decode(V& v)
10965                 {
10966                         clear();
10967                         if(!v(ref_nested())) return false;
10968                         { type = 1; return true;}
10969                         return false;
10970
10971                 }
10972                 template<typename V> bool encode(V& v) const
10973                 {
10974                         return v(ref_nested());
10975
10976                 }
10977                 protected:
10978                 template<typename V>  bool decode(size_t index, V& v)
10979                 {
10980                         clear();
10981                         switch(index)
10982                         {
10983                         case 1: type = 1; return v(ref_nested());
10984                         ref_nested().clear();
10985                         }
10986                         return false;
10987
10988                 }
10989                 template<typename V> bool encode(size_t index, V& v) const
10990                 {
10991                         if(index != type) {return false;} return v(ref_nested());
10992
10993                 }
10994                 private:
10995                 size_t type {0};
10996
10997         };
10998         struct Extension_t : asn::typefield<true>
10999         {
11000                 ~Extension_t()  {clear();}
11001                 size_t get_index() const {return type;}
11002                 bool is_unknown() const { return type == 1; }
11003                 void clear()
11004                 {
11005                         type = 0; ref_nested().clear();
11006                 }
11007                 template<typename V> static inline void enumerate(V& v)
11008                 {
11009
11010                 }
11011                 protected:
11012                 template<typename V> bool decode(size_t index, V& v)
11013                 {
11014                         clear();
11015                         switch(index)
11016                         {
11017                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11018                         }
11019                         return false;
11020
11021                 }
11022                 template<typename V> bool encode(size_t index, V& v) const
11023                 {
11024                         if(index != type) return false;
11025                         return false;
11026
11027                 }
11028                 private:
11029                 size_t type {0};
11030
11031         };
11032         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11033         {
11034                 size_t get_index() const {return type;}
11035                 bool is_unknown() const { return type == 1; }
11036                 void clear() {type = 0;}
11037                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11038                 template<typename V>  bool decode(V& v)
11039                 {
11040                         clear();
11041                         if(!v(ref_nested())) return false;
11042                         { type = 1; return true;}
11043                         return false;
11044
11045                 }
11046                 template<typename V> bool encode(V& v) const
11047                 {
11048                         return v(ref_nested());
11049
11050                 }
11051                 protected:
11052                 template<typename V>  bool decode(size_t index, V& v)
11053                 {
11054                         clear();
11055                         switch(index)
11056                         {
11057                         case 1: type = 1; return v(ref_nested());
11058                         ref_nested().clear();
11059                         }
11060                         return false;
11061
11062                 }
11063                 template<typename V> bool encode(size_t index, V& v) const
11064                 {
11065                         if(index != type) {return false;} return v(ref_nested());
11066
11067                 }
11068                 private:
11069                 size_t type {0};
11070
11071         };
11072
11073 };
11074 /*
11075 E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer ::= SEQUENCE {
11076         e-RAB-ID                                        E-RAB-ID,
11077         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-BearerExtIEs} }       OPTIONAL,
11078         ...
11079 }
11080 */
11081
11082 struct E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer : asn::sequence<2, 0, true, 1>
11083 {
11084         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer";}
11085         using parent_t = asn::sequence<2, 0, true, 1>;
11086         struct e_RAB_ID_t : E_RAB_ID
11087         {
11088                 static constexpr const char* name() {return "e_RAB_ID_t";}
11089                 using parent_t = E_RAB_ID;
11090
11091         };
11092         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
11093         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
11094         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>
11095         {
11096                 static constexpr const char* name() {return "iE_Extensions_t";}
11097                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_BearerExtIEs>;
11098                 static constexpr bool optional = true;
11099
11100         };
11101         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11102         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11103         template<typename V> void decode(V& v)
11104         {
11105                 v(e_RAB_ID);
11106                 v(iE_Extensions);
11107
11108         };
11109         template<typename V> void encode(V& v) const
11110         {
11111                 v(e_RAB_ID);
11112                 v(iE_Extensions);
11113
11114         };
11115         void clear()
11116         {
11117                 e_RAB_ID.clear();
11118                 iE_Extensions.clear();
11119
11120         };
11121         private:
11122         e_RAB_ID_t      e_RAB_ID;
11123         iE_Extensions_t iE_Extensions;
11124
11125 };
11126 /*
11127 E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11128         ...
11129 }
11130 */
11131
11132 struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs
11133 {
11134         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11135         {
11136                 size_t get_index() const {return type;}
11137                 bool is_unknown() const { return type == 1; }
11138                 void clear() {type = 0;}
11139                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11140                 template<typename V>  bool decode(V& v)
11141                 {
11142                         clear();
11143                         if(!v(ref_nested())) return false;
11144                         { type = 1; return true;}
11145                         return false;
11146
11147                 }
11148                 template<typename V> bool encode(V& v) const
11149                 {
11150                         return v(ref_nested());
11151
11152                 }
11153                 protected:
11154                 template<typename V>  bool decode(size_t index, V& v)
11155                 {
11156                         clear();
11157                         switch(index)
11158                         {
11159                         case 1: type = 1; return v(ref_nested());
11160                         ref_nested().clear();
11161                         }
11162                         return false;
11163
11164                 }
11165                 template<typename V> bool encode(size_t index, V& v) const
11166                 {
11167                         if(index != type) {return false;} return v(ref_nested());
11168
11169                 }
11170                 private:
11171                 size_t type {0};
11172
11173         };
11174         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11175         {
11176                 size_t get_index() const {return type;}
11177                 bool is_unknown() const { return type == 1; }
11178                 void clear() {type = 0;}
11179                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11180                 template<typename V>  bool decode(V& v)
11181                 {
11182                         clear();
11183                         if(!v(ref_nested())) return false;
11184                         { type = 1; return true;}
11185                         return false;
11186
11187                 }
11188                 template<typename V> bool encode(V& v) const
11189                 {
11190                         return v(ref_nested());
11191
11192                 }
11193                 protected:
11194                 template<typename V>  bool decode(size_t index, V& v)
11195                 {
11196                         clear();
11197                         switch(index)
11198                         {
11199                         case 1: type = 1; return v(ref_nested());
11200                         ref_nested().clear();
11201                         }
11202                         return false;
11203
11204                 }
11205                 template<typename V> bool encode(size_t index, V& v) const
11206                 {
11207                         if(index != type) {return false;} return v(ref_nested());
11208
11209                 }
11210                 private:
11211                 size_t type {0};
11212
11213         };
11214         struct Extension_t : asn::typefield<true>
11215         {
11216                 ~Extension_t()  {clear();}
11217                 size_t get_index() const {return type;}
11218                 bool is_unknown() const { return type == 1; }
11219                 void clear()
11220                 {
11221                         type = 0; ref_nested().clear();
11222                 }
11223                 template<typename V> static inline void enumerate(V& v)
11224                 {
11225
11226                 }
11227                 protected:
11228                 template<typename V> bool decode(size_t index, V& v)
11229                 {
11230                         clear();
11231                         switch(index)
11232                         {
11233                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11234                         }
11235                         return false;
11236
11237                 }
11238                 template<typename V> bool encode(size_t index, V& v) const
11239                 {
11240                         if(index != type) return false;
11241                         return false;
11242
11243                 }
11244                 private:
11245                 size_t type {0};
11246
11247         };
11248         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11249         {
11250                 size_t get_index() const {return type;}
11251                 bool is_unknown() const { return type == 1; }
11252                 void clear() {type = 0;}
11253                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11254                 template<typename V>  bool decode(V& v)
11255                 {
11256                         clear();
11257                         if(!v(ref_nested())) return false;
11258                         { type = 1; return true;}
11259                         return false;
11260
11261                 }
11262                 template<typename V> bool encode(V& v) const
11263                 {
11264                         return v(ref_nested());
11265
11266                 }
11267                 protected:
11268                 template<typename V>  bool decode(size_t index, V& v)
11269                 {
11270                         clear();
11271                         switch(index)
11272                         {
11273                         case 1: type = 1; return v(ref_nested());
11274                         ref_nested().clear();
11275                         }
11276                         return false;
11277
11278                 }
11279                 template<typename V> bool encode(size_t index, V& v) const
11280                 {
11281                         if(index != type) {return false;} return v(ref_nested());
11282
11283                 }
11284                 private:
11285                 size_t type {0};
11286
11287         };
11288
11289 };
11290 /*
11291 E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer ::= SEQUENCE {
11292         e-RAB-ID                                        E-RAB-ID,
11293         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-ModAckItem-Split-BearerExtIEs} } OPTIONAL,
11294         ...
11295 }
11296 */
11297
11298 struct E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer : asn::sequence<2, 0, true, 1>
11299 {
11300         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer";}
11301         using parent_t = asn::sequence<2, 0, true, 1>;
11302         struct e_RAB_ID_t : E_RAB_ID
11303         {
11304                 static constexpr const char* name() {return "e_RAB_ID_t";}
11305                 using parent_t = E_RAB_ID;
11306
11307         };
11308         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
11309         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
11310         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>
11311         {
11312                 static constexpr const char* name() {return "iE_Extensions_t";}
11313                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_ModAckItem_Split_BearerExtIEs>;
11314                 static constexpr bool optional = true;
11315
11316         };
11317         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11318         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11319         template<typename V> void decode(V& v)
11320         {
11321                 v(e_RAB_ID);
11322                 v(iE_Extensions);
11323
11324         };
11325         template<typename V> void encode(V& v) const
11326         {
11327                 v(e_RAB_ID);
11328                 v(iE_Extensions);
11329
11330         };
11331         void clear()
11332         {
11333                 e_RAB_ID.clear();
11334                 iE_Extensions.clear();
11335
11336         };
11337         private:
11338         e_RAB_ID_t      e_RAB_ID;
11339         iE_Extensions_t iE_Extensions;
11340
11341 };
11342 /*
11343 E-RABs-Admitted-ToReleased-ModAckItem ::= CHOICE {
11344         sCG-Bearer              E-RABs-Admitted-ToBeReleased-ModAckItem-SCG-Bearer,
11345         split-Bearer    E-RABs-Admitted-ToBeReleased-ModAckItem-Split-Bearer,
11346         ...
11347 }
11348 */
11349
11350 struct E_RABs_Admitted_ToReleased_ModAckItem : asn::choice<2, 0, true>
11351 {
11352         static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-ModAckItem";}
11353         using parent_t = asn::choice<2, 0, true>;
11354         index_type get_index() const {return index;}
11355         bool is_unknown() const {return index == 3;}
11356         void set_unknown() { set_index(3);  }
11357         ~E_RABs_Admitted_ToReleased_ModAckItem() {clear();}
11358         struct sCG_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer
11359         {
11360                 static constexpr const char* name() {return "sCG_Bearer_t";}
11361                 using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_SCG_Bearer;
11362
11363         };
11364         struct split_Bearer_t : E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer
11365         {
11366                 static constexpr const char* name() {return "split_Bearer_t";}
11367                 using parent_t = E_RABs_Admitted_ToBeReleased_ModAckItem_Split_Bearer;
11368
11369         };
11370         void clear()
11371         {
11372                 switch(get_index())
11373                 {
11374                 case 1: var.destroy<sCG_Bearer_t>(); break;
11375                 case 2: var.destroy<split_Bearer_t>(); break;
11376                 }
11377                 index = 0;
11378                 base::clear();
11379         }
11380         template<typename V> bool decode(size_t idx, V& v)
11381         {
11382                 clear();
11383                 switch(idx)
11384                 {
11385                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
11386                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
11387                 }
11388                 return false;
11389
11390         }
11391         template<typename V> bool encode(V& v) const
11392         {
11393                 switch(get_index())
11394                 {
11395                 case 1: return v(var.as<sCG_Bearer_t>());
11396                 case 2: return v(var.as<split_Bearer_t>());
11397                 }
11398                 return false;
11399         }
11400         template<typename V> static inline void enumerate(V& v)
11401         {
11402                 v.template operator()<sCG_Bearer_t>(1);
11403                 v.template operator()<split_Bearer_t>(2);
11404
11405         }
11406         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
11407         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
11408         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
11409         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
11410         private:
11411         void set_index(index_type i) {index = i; base::set();}
11412         union union_type
11413         {
11414                 char dummy1[sizeof(sCG_Bearer_t)];
11415                 char dummy2[sizeof(split_Bearer_t)];
11416
11417         };
11418         asn::variant<sizeof(union_type)>        var;
11419         index_type      index {0};
11420 };
11421 /*
11422 E-RABs-Admitted-ToBeReleased-ModAckItemIEs X2AP-PROTOCOL-IES ::= {
11423         { ID id-E-RABs-Admitted-ToBeReleased-ModAckItem         CRITICALITY ignore      TYPE E-RABs-Admitted-ToReleased-ModAckItem              PRESENCE mandatory}
11424 }
11425 */
11426
11427 struct E_RABs_Admitted_ToBeReleased_ModAckItemIEs
11428 {
11429         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
11430         {
11431                 size_t get_index() const {return type;}
11432                 void clear() {type = 0;}
11433                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(id_E_RABs_Admitted_ToBeReleased_ModAckItem); type=1;}
11434                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
11435                 template<typename V>  bool decode(V& v)
11436                 {
11437                         clear();
11438                         if(!v(ref_nested())) return false;
11439                         if(equal(id_E_RABs_Admitted_ToBeReleased_ModAckItem)) { type = 1; return true; }
11440                         return false;
11441
11442                 }
11443                 template<typename V> bool encode(V& v) const
11444                 {
11445                         return v(ref_nested());
11446
11447                 }
11448                 protected:
11449                 template<typename V>  bool decode(size_t index, V& v)
11450                 {
11451                         clear();
11452                         switch(index)
11453                         {
11454                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_ModAckItem);} return false;
11455                         ref_nested().clear();
11456                         }
11457                         return false;
11458
11459                 }
11460                 template<typename V> bool encode(size_t index, V& v) const
11461                 {
11462                         if(index != type) {return false;} return v(ref_nested());
11463
11464                 }
11465                 private:
11466                 size_t type {0};
11467
11468         };
11469         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
11470         {
11471                 size_t get_index() const {return type;}
11472                 void clear() {type = 0;}
11473                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(ignore); type=1;}
11474                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
11475                 template<typename V>  bool decode(V& v)
11476                 {
11477                         clear();
11478                         if(!v(ref_nested())) return false;
11479                         if(equal(ignore)) { type = 1; return true; }
11480                         return false;
11481
11482                 }
11483                 template<typename V> bool encode(V& v) const
11484                 {
11485                         return v(ref_nested());
11486
11487                 }
11488                 protected:
11489                 template<typename V>  bool decode(size_t index, V& v)
11490                 {
11491                         clear();
11492                         switch(index)
11493                         {
11494                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
11495                         ref_nested().clear();
11496                         }
11497                         return false;
11498
11499                 }
11500                 template<typename V> bool encode(size_t index, V& v) const
11501                 {
11502                         if(index != type) {return false;} return v(ref_nested());
11503
11504                 }
11505                 private:
11506                 size_t type {0};
11507
11508         };
11509         struct Value_t : asn::typefield<false>
11510         {
11511                 ~Value_t()      {clear();}
11512                 size_t get_index() const {return type;}
11513                 E_RABs_Admitted_ToReleased_ModAckItem& select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { return set<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
11514                 E_RABs_Admitted_ToReleased_ModAckItem const* get_id_E_RABs_Admitted_ToBeReleased_ModAckItem() const { return get<E_RABs_Admitted_ToReleased_ModAckItem>(1); }
11515                 void clear()
11516                 {
11517                         switch(type)
11518                         {
11519                         case 1: var.destroy<E_RABs_Admitted_ToReleased_ModAckItem>(); break;
11520                         }
11521                         type = 0; ref_nested().clear();
11522                 }
11523                 template<typename V> static inline void enumerate(V& v)
11524                 {
11525                         v.template operator()<E_RABs_Admitted_ToReleased_ModAckItem>(1);
11526
11527                 }
11528                 protected:
11529                 template<typename V> bool decode(size_t index, V& v)
11530                 {
11531                         clear();
11532                         switch(index)
11533                         {
11534                         case 1: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckItem()); return true;
11535                         }
11536                         return false;
11537
11538                 }
11539                 template<typename V> bool encode(size_t index, V& v) const
11540                 {
11541                         if(index != type) return false;
11542                         switch(type)
11543                         {
11544                         case 1: v(var.as<E_RABs_Admitted_ToReleased_ModAckItem>()); return true;
11545                         }
11546                         return false;
11547
11548                 }
11549                 private:
11550                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
11551                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
11552                 union union_type
11553                 {
11554                         char dummy1[sizeof(E_RABs_Admitted_ToReleased_ModAckItem)];
11555
11556                 };
11557                 asn::variant<sizeof(union_type)> var;
11558                 size_t type {0};
11559
11560         };
11561         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
11562         {
11563                 size_t get_index() const {return type;}
11564                 void clear() {type = 0;}
11565                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckItem() { set(mandatory); type=1;}
11566                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
11567                 template<typename V>  bool decode(V& v)
11568                 {
11569                         clear();
11570                         if(!v(ref_nested())) return false;
11571                         if(equal(mandatory)) { type = 1; return true; }
11572                         return false;
11573
11574                 }
11575                 template<typename V> bool encode(V& v) const
11576                 {
11577                         return v(ref_nested());
11578
11579                 }
11580                 protected:
11581                 template<typename V>  bool decode(size_t index, V& v)
11582                 {
11583                         clear();
11584                         switch(index)
11585                         {
11586                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
11587                         ref_nested().clear();
11588                         }
11589                         return false;
11590
11591                 }
11592                 template<typename V> bool encode(size_t index, V& v) const
11593                 {
11594                         if(index != type) {return false;} return v(ref_nested());
11595
11596                 }
11597                 private:
11598                 size_t type {0};
11599
11600         };
11601
11602 };
11603 /*
11604 E-RABs-Admitted-ToBeReleased-ModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-ModAckItemIEs} }
11605 */
11606
11607 struct E_RABs_Admitted_ToBeReleased_ModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>
11608 {
11609         static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_ModAckList_elm";}
11610         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_ModAckItemIEs>;
11611
11612 };
11613 struct E_RABs_Admitted_ToBeReleased_ModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>
11614 {
11615         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-ModAckList";}
11616         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_ModAckList_elm>;
11617         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
11618
11619 };
11620 /*
11621 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11622         ...
11623 }
11624 */
11625
11626 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs
11627 {
11628         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11629         {
11630                 size_t get_index() const {return type;}
11631                 bool is_unknown() const { return type == 1; }
11632                 void clear() {type = 0;}
11633                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11634                 template<typename V>  bool decode(V& v)
11635                 {
11636                         clear();
11637                         if(!v(ref_nested())) return false;
11638                         { type = 1; return true;}
11639                         return false;
11640
11641                 }
11642                 template<typename V> bool encode(V& v) const
11643                 {
11644                         return v(ref_nested());
11645
11646                 }
11647                 protected:
11648                 template<typename V>  bool decode(size_t index, V& v)
11649                 {
11650                         clear();
11651                         switch(index)
11652                         {
11653                         case 1: type = 1; return v(ref_nested());
11654                         ref_nested().clear();
11655                         }
11656                         return false;
11657
11658                 }
11659                 template<typename V> bool encode(size_t index, V& v) const
11660                 {
11661                         if(index != type) {return false;} return v(ref_nested());
11662
11663                 }
11664                 private:
11665                 size_t type {0};
11666
11667         };
11668         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11669         {
11670                 size_t get_index() const {return type;}
11671                 bool is_unknown() const { return type == 1; }
11672                 void clear() {type = 0;}
11673                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11674                 template<typename V>  bool decode(V& v)
11675                 {
11676                         clear();
11677                         if(!v(ref_nested())) return false;
11678                         { type = 1; return true;}
11679                         return false;
11680
11681                 }
11682                 template<typename V> bool encode(V& v) const
11683                 {
11684                         return v(ref_nested());
11685
11686                 }
11687                 protected:
11688                 template<typename V>  bool decode(size_t index, V& v)
11689                 {
11690                         clear();
11691                         switch(index)
11692                         {
11693                         case 1: type = 1; return v(ref_nested());
11694                         ref_nested().clear();
11695                         }
11696                         return false;
11697
11698                 }
11699                 template<typename V> bool encode(size_t index, V& v) const
11700                 {
11701                         if(index != type) {return false;} return v(ref_nested());
11702
11703                 }
11704                 private:
11705                 size_t type {0};
11706
11707         };
11708         struct Extension_t : asn::typefield<true>
11709         {
11710                 ~Extension_t()  {clear();}
11711                 size_t get_index() const {return type;}
11712                 bool is_unknown() const { return type == 1; }
11713                 void clear()
11714                 {
11715                         type = 0; ref_nested().clear();
11716                 }
11717                 template<typename V> static inline void enumerate(V& v)
11718                 {
11719
11720                 }
11721                 protected:
11722                 template<typename V> bool decode(size_t index, V& v)
11723                 {
11724                         clear();
11725                         switch(index)
11726                         {
11727                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11728                         }
11729                         return false;
11730
11731                 }
11732                 template<typename V> bool encode(size_t index, V& v) const
11733                 {
11734                         if(index != type) return false;
11735                         return false;
11736
11737                 }
11738                 private:
11739                 size_t type {0};
11740
11741         };
11742         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11743         {
11744                 size_t get_index() const {return type;}
11745                 bool is_unknown() const { return type == 1; }
11746                 void clear() {type = 0;}
11747                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11748                 template<typename V>  bool decode(V& v)
11749                 {
11750                         clear();
11751                         if(!v(ref_nested())) return false;
11752                         { type = 1; return true;}
11753                         return false;
11754
11755                 }
11756                 template<typename V> bool encode(V& v) const
11757                 {
11758                         return v(ref_nested());
11759
11760                 }
11761                 protected:
11762                 template<typename V>  bool decode(size_t index, V& v)
11763                 {
11764                         clear();
11765                         switch(index)
11766                         {
11767                         case 1: type = 1; return v(ref_nested());
11768                         ref_nested().clear();
11769                         }
11770                         return false;
11771
11772                 }
11773                 template<typename V> bool encode(size_t index, V& v) const
11774                 {
11775                         if(index != type) {return false;} return v(ref_nested());
11776
11777                 }
11778                 private:
11779                 size_t type {0};
11780
11781         };
11782
11783 };
11784 /*
11785 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent ::= SEQUENCE {
11786         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresentExtIEs} } OPTIONAL,
11787         ...
11788 }
11789 */
11790
11791 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
11792 {
11793         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent";}
11794         using parent_t = asn::sequence<1, 0, true, 1>;
11795         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>
11796         {
11797                 static constexpr const char* name() {return "iE_Extensions_t";}
11798                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresentExtIEs>;
11799                 static constexpr bool optional = true;
11800
11801         };
11802         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11803         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11804         template<typename V> void decode(V& v)
11805         {
11806                 v(iE_Extensions);
11807
11808         };
11809         template<typename V> void encode(V& v) const
11810         {
11811                 v(iE_Extensions);
11812
11813         };
11814         void clear()
11815         {
11816                 iE_Extensions.clear();
11817
11818         };
11819         private:
11820         iE_Extensions_t iE_Extensions;
11821
11822 };
11823 /*
11824 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11825         ...
11826 }
11827 */
11828
11829 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs
11830 {
11831         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11832         {
11833                 size_t get_index() const {return type;}
11834                 bool is_unknown() const { return type == 1; }
11835                 void clear() {type = 0;}
11836                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11837                 template<typename V>  bool decode(V& v)
11838                 {
11839                         clear();
11840                         if(!v(ref_nested())) return false;
11841                         { type = 1; return true;}
11842                         return false;
11843
11844                 }
11845                 template<typename V> bool encode(V& v) const
11846                 {
11847                         return v(ref_nested());
11848
11849                 }
11850                 protected:
11851                 template<typename V>  bool decode(size_t index, V& v)
11852                 {
11853                         clear();
11854                         switch(index)
11855                         {
11856                         case 1: type = 1; return v(ref_nested());
11857                         ref_nested().clear();
11858                         }
11859                         return false;
11860
11861                 }
11862                 template<typename V> bool encode(size_t index, V& v) const
11863                 {
11864                         if(index != type) {return false;} return v(ref_nested());
11865
11866                 }
11867                 private:
11868                 size_t type {0};
11869
11870         };
11871         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11872         {
11873                 size_t get_index() const {return type;}
11874                 bool is_unknown() const { return type == 1; }
11875                 void clear() {type = 0;}
11876                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11877                 template<typename V>  bool decode(V& v)
11878                 {
11879                         clear();
11880                         if(!v(ref_nested())) return false;
11881                         { type = 1; return true;}
11882                         return false;
11883
11884                 }
11885                 template<typename V> bool encode(V& v) const
11886                 {
11887                         return v(ref_nested());
11888
11889                 }
11890                 protected:
11891                 template<typename V>  bool decode(size_t index, V& v)
11892                 {
11893                         clear();
11894                         switch(index)
11895                         {
11896                         case 1: type = 1; return v(ref_nested());
11897                         ref_nested().clear();
11898                         }
11899                         return false;
11900
11901                 }
11902                 template<typename V> bool encode(size_t index, V& v) const
11903                 {
11904                         if(index != type) {return false;} return v(ref_nested());
11905
11906                 }
11907                 private:
11908                 size_t type {0};
11909
11910         };
11911         struct Extension_t : asn::typefield<true>
11912         {
11913                 ~Extension_t()  {clear();}
11914                 size_t get_index() const {return type;}
11915                 bool is_unknown() const { return type == 1; }
11916                 void clear()
11917                 {
11918                         type = 0; ref_nested().clear();
11919                 }
11920                 template<typename V> static inline void enumerate(V& v)
11921                 {
11922
11923                 }
11924                 protected:
11925                 template<typename V> bool decode(size_t index, V& v)
11926                 {
11927                         clear();
11928                         switch(index)
11929                         {
11930                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11931                         }
11932                         return false;
11933
11934                 }
11935                 template<typename V> bool encode(size_t index, V& v) const
11936                 {
11937                         if(index != type) return false;
11938                         return false;
11939
11940                 }
11941                 private:
11942                 size_t type {0};
11943
11944         };
11945         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11946         {
11947                 size_t get_index() const {return type;}
11948                 bool is_unknown() const { return type == 1; }
11949                 void clear() {type = 0;}
11950                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11951                 template<typename V>  bool decode(V& v)
11952                 {
11953                         clear();
11954                         if(!v(ref_nested())) return false;
11955                         { type = 1; return true;}
11956                         return false;
11957
11958                 }
11959                 template<typename V> bool encode(V& v) const
11960                 {
11961                         return v(ref_nested());
11962
11963                 }
11964                 protected:
11965                 template<typename V>  bool decode(size_t index, V& v)
11966                 {
11967                         clear();
11968                         switch(index)
11969                         {
11970                         case 1: type = 1; return v(ref_nested());
11971                         ref_nested().clear();
11972                         }
11973                         return false;
11974
11975                 }
11976                 template<typename V> bool encode(size_t index, V& v) const
11977                 {
11978                         if(index != type) {return false;} return v(ref_nested());
11979
11980                 }
11981                 private:
11982                 size_t type {0};
11983
11984         };
11985
11986 };
11987 /*
11988 E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent ::= SEQUENCE {
11989         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresentExtIEs} }             OPTIONAL,
11990         ...
11991 }
11992 */
11993
11994 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
11995 {
11996         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent";}
11997         using parent_t = asn::sequence<1, 0, true, 1>;
11998         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>
11999         {
12000                 static constexpr const char* name() {return "iE_Extensions_t";}
12001                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresentExtIEs>;
12002                 static constexpr bool optional = true;
12003
12004         };
12005         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12006         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12007         template<typename V> void decode(V& v)
12008         {
12009                 v(iE_Extensions);
12010
12011         };
12012         template<typename V> void encode(V& v) const
12013         {
12014                 v(iE_Extensions);
12015
12016         };
12017         void clear()
12018         {
12019                 iE_Extensions.clear();
12020
12021         };
12022         private:
12023         iE_Extensions_t iE_Extensions;
12024
12025 };
12026 /*
12027 E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12028         ...
12029 }
12030 */
12031
12032 struct E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs
12033 {
12034         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12035         {
12036                 size_t get_index() const {return type;}
12037                 bool is_unknown() const { return type == 1; }
12038                 void clear() {type = 0;}
12039                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12040                 template<typename V>  bool decode(V& v)
12041                 {
12042                         clear();
12043                         if(!v(ref_nested())) return false;
12044                         { type = 1; return true;}
12045                         return false;
12046
12047                 }
12048                 template<typename V> bool encode(V& v) const
12049                 {
12050                         return v(ref_nested());
12051
12052                 }
12053                 protected:
12054                 template<typename V>  bool decode(size_t index, V& v)
12055                 {
12056                         clear();
12057                         switch(index)
12058                         {
12059                         case 1: type = 1; return v(ref_nested());
12060                         ref_nested().clear();
12061                         }
12062                         return false;
12063
12064                 }
12065                 template<typename V> bool encode(size_t index, V& v) const
12066                 {
12067                         if(index != type) {return false;} return v(ref_nested());
12068
12069                 }
12070                 private:
12071                 size_t type {0};
12072
12073         };
12074         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12075         {
12076                 size_t get_index() const {return type;}
12077                 bool is_unknown() const { return type == 1; }
12078                 void clear() {type = 0;}
12079                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12080                 template<typename V>  bool decode(V& v)
12081                 {
12082                         clear();
12083                         if(!v(ref_nested())) return false;
12084                         { type = 1; return true;}
12085                         return false;
12086
12087                 }
12088                 template<typename V> bool encode(V& v) const
12089                 {
12090                         return v(ref_nested());
12091
12092                 }
12093                 protected:
12094                 template<typename V>  bool decode(size_t index, V& v)
12095                 {
12096                         clear();
12097                         switch(index)
12098                         {
12099                         case 1: type = 1; return v(ref_nested());
12100                         ref_nested().clear();
12101                         }
12102                         return false;
12103
12104                 }
12105                 template<typename V> bool encode(size_t index, V& v) const
12106                 {
12107                         if(index != type) {return false;} return v(ref_nested());
12108
12109                 }
12110                 private:
12111                 size_t type {0};
12112
12113         };
12114         struct Extension_t : asn::typefield<true>
12115         {
12116                 ~Extension_t()  {clear();}
12117                 size_t get_index() const {return type;}
12118                 bool is_unknown() const { return type == 1; }
12119                 void clear()
12120                 {
12121                         type = 0; ref_nested().clear();
12122                 }
12123                 template<typename V> static inline void enumerate(V& v)
12124                 {
12125
12126                 }
12127                 protected:
12128                 template<typename V> bool decode(size_t index, V& v)
12129                 {
12130                         clear();
12131                         switch(index)
12132                         {
12133                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12134                         }
12135                         return false;
12136
12137                 }
12138                 template<typename V> bool encode(size_t index, V& v) const
12139                 {
12140                         if(index != type) return false;
12141                         return false;
12142
12143                 }
12144                 private:
12145                 size_t type {0};
12146
12147         };
12148         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12149         {
12150                 size_t get_index() const {return type;}
12151                 bool is_unknown() const { return type == 1; }
12152                 void clear() {type = 0;}
12153                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12154                 template<typename V>  bool decode(V& v)
12155                 {
12156                         clear();
12157                         if(!v(ref_nested())) return false;
12158                         { type = 1; return true;}
12159                         return false;
12160
12161                 }
12162                 template<typename V> bool encode(V& v) const
12163                 {
12164                         return v(ref_nested());
12165
12166                 }
12167                 protected:
12168                 template<typename V>  bool decode(size_t index, V& v)
12169                 {
12170                         clear();
12171                         switch(index)
12172                         {
12173                         case 1: type = 1; return v(ref_nested());
12174                         ref_nested().clear();
12175                         }
12176                         return false;
12177
12178                 }
12179                 template<typename V> bool encode(size_t index, V& v) const
12180                 {
12181                         if(index != type) {return false;} return v(ref_nested());
12182
12183                 }
12184                 private:
12185                 size_t type {0};
12186
12187         };
12188
12189 };
12190 /*
12191 E-RABs-Admitted-ToReleased-SgNBModAck-Item ::= SEQUENCE {
12192         e-RAB-ID                                                        E-RAB-ID,
12193         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
12194         resource-configuration                          CHOICE {
12195                 sgNBPDCPpresent                                         E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPpresent,
12196                 sgNBPDCPnotpresent                                      E-RABs-Admitted-ToBeReleased-SgNBModAck-Item-SgNBPDCPnotpresent,
12197                 ...
12198         },
12199         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModAck-ItemExtIEs} }      OPTIONAL,
12200         ...
12201 }
12202 */
12203
12204 struct E_RABs_Admitted_ToReleased_SgNBModAck_Item : asn::sequence<4, 0, true, 1>
12205 {
12206         static constexpr const char* name() {return "E-RABs-Admitted-ToReleased-SgNBModAck-Item";}
12207         using parent_t = asn::sequence<4, 0, true, 1>;
12208         struct e_RAB_ID_t : E_RAB_ID
12209         {
12210                 static constexpr const char* name() {return "e_RAB_ID_t";}
12211                 using parent_t = E_RAB_ID;
12212
12213         };
12214         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
12215         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
12216         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
12217         {
12218                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
12219                 using parent_t = EN_DC_ResourceConfiguration;
12220
12221         };
12222         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
12223         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
12224         struct resource_configuration_t : asn::choice<2, 0, true>
12225         {
12226                 static constexpr const char* name() {return "resource_configuration_t";}
12227                 using parent_t = asn::choice<2, 0, true>;
12228                 index_type get_index() const {return index;}
12229                 bool is_unknown() const {return index == 3;}
12230                 void set_unknown() { set_index(3);  }
12231                 ~resource_configuration_t() {clear();}
12232                 struct sgNBPDCPpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent
12233                 {
12234                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
12235                         using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPpresent;
12236
12237                 };
12238                 struct sgNBPDCPnotpresent_t : E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent
12239                 {
12240                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
12241                         using parent_t = E_RABs_Admitted_ToBeReleased_SgNBModAck_Item_SgNBPDCPnotpresent;
12242
12243                 };
12244                 void clear()
12245                 {
12246                         switch(get_index())
12247                         {
12248                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
12249                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
12250                         }
12251                         index = 0;
12252                         base::clear();
12253                 }
12254                 template<typename V> bool decode(size_t idx, V& v)
12255                 {
12256                         clear();
12257                         switch(idx)
12258                         {
12259                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
12260                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
12261                         }
12262                         return false;
12263
12264                 }
12265                 template<typename V> bool encode(V& v) const
12266                 {
12267                         switch(get_index())
12268                         {
12269                         case 1: return v(var.as<sgNBPDCPpresent_t>());
12270                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
12271                         }
12272                         return false;
12273                 }
12274                 template<typename V> static inline void enumerate(V& v)
12275                 {
12276                         v.template operator()<sgNBPDCPpresent_t>(1);
12277                         v.template operator()<sgNBPDCPnotpresent_t>(2);
12278
12279                 }
12280                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
12281                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
12282                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
12283                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
12284                 private:
12285                 void set_index(index_type i) {index = i; base::set();}
12286                 union union_type
12287                 {
12288                         char dummy1[sizeof(sgNBPDCPpresent_t)];
12289                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
12290
12291                 };
12292                 asn::variant<sizeof(union_type)>        var;
12293                 index_type      index {0};
12294         };
12295         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
12296         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
12297         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>
12298         {
12299                 static constexpr const char* name() {return "iE_Extensions_t";}
12300                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModAck_ItemExtIEs>;
12301                 static constexpr bool optional = true;
12302
12303         };
12304         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12305         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12306         template<typename V> void decode(V& v)
12307         {
12308                 v(e_RAB_ID);
12309                 v(en_DC_ResourceConfiguration);
12310                 v(resource_configuration);
12311                 v(iE_Extensions);
12312
12313         };
12314         template<typename V> void encode(V& v) const
12315         {
12316                 v(e_RAB_ID);
12317                 v(en_DC_ResourceConfiguration);
12318                 v(resource_configuration);
12319                 v(iE_Extensions);
12320
12321         };
12322         void clear()
12323         {
12324                 e_RAB_ID.clear();
12325                 en_DC_ResourceConfiguration.clear();
12326                 resource_configuration.clear();
12327                 iE_Extensions.clear();
12328
12329         };
12330         private:
12331         e_RAB_ID_t      e_RAB_ID;
12332         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
12333         resource_configuration_t        resource_configuration;
12334         iE_Extensions_t iE_Extensions;
12335
12336 };
12337 /*
12338 E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs X2AP-PROTOCOL-IES ::= {
12339         { ID id-E-RABs-Admitted-ToBeReleased-SgNBModAck-Item            CRITICALITY ignore      TYPE E-RABs-Admitted-ToReleased-SgNBModAck-Item         PRESENCE mandatory}
12340 }
12341 */
12342
12343 struct E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs
12344 {
12345         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
12346         {
12347                 size_t get_index() const {return type;}
12348                 void clear() {type = 0;}
12349                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item); type=1;}
12350                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
12351                 template<typename V>  bool decode(V& v)
12352                 {
12353                         clear();
12354                         if(!v(ref_nested())) return false;
12355                         if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item)) { type = 1; return true; }
12356                         return false;
12357
12358                 }
12359                 template<typename V> bool encode(V& v) const
12360                 {
12361                         return v(ref_nested());
12362
12363                 }
12364                 protected:
12365                 template<typename V>  bool decode(size_t index, V& v)
12366                 {
12367                         clear();
12368                         switch(index)
12369                         {
12370                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item);} return false;
12371                         ref_nested().clear();
12372                         }
12373                         return false;
12374
12375                 }
12376                 template<typename V> bool encode(size_t index, V& v) const
12377                 {
12378                         if(index != type) {return false;} return v(ref_nested());
12379
12380                 }
12381                 private:
12382                 size_t type {0};
12383
12384         };
12385         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
12386         {
12387                 size_t get_index() const {return type;}
12388                 void clear() {type = 0;}
12389                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(ignore); type=1;}
12390                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
12391                 template<typename V>  bool decode(V& v)
12392                 {
12393                         clear();
12394                         if(!v(ref_nested())) return false;
12395                         if(equal(ignore)) { type = 1; return true; }
12396                         return false;
12397
12398                 }
12399                 template<typename V> bool encode(V& v) const
12400                 {
12401                         return v(ref_nested());
12402
12403                 }
12404                 protected:
12405                 template<typename V>  bool decode(size_t index, V& v)
12406                 {
12407                         clear();
12408                         switch(index)
12409                         {
12410                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
12411                         ref_nested().clear();
12412                         }
12413                         return false;
12414
12415                 }
12416                 template<typename V> bool encode(size_t index, V& v) const
12417                 {
12418                         if(index != type) {return false;} return v(ref_nested());
12419
12420                 }
12421                 private:
12422                 size_t type {0};
12423
12424         };
12425         struct Value_t : asn::typefield<false>
12426         {
12427                 ~Value_t()      {clear();}
12428                 size_t get_index() const {return type;}
12429                 E_RABs_Admitted_ToReleased_SgNBModAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { return set<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
12430                 E_RABs_Admitted_ToReleased_SgNBModAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() const { return get<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1); }
12431                 void clear()
12432                 {
12433                         switch(type)
12434                         {
12435                         case 1: var.destroy<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(); break;
12436                         }
12437                         type = 0; ref_nested().clear();
12438                 }
12439                 template<typename V> static inline void enumerate(V& v)
12440                 {
12441                         v.template operator()<E_RABs_Admitted_ToReleased_SgNBModAck_Item>(1);
12442
12443                 }
12444                 protected:
12445                 template<typename V> bool decode(size_t index, V& v)
12446                 {
12447                         clear();
12448                         switch(index)
12449                         {
12450                         case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item()); return true;
12451                         }
12452                         return false;
12453
12454                 }
12455                 template<typename V> bool encode(size_t index, V& v) const
12456                 {
12457                         if(index != type) return false;
12458                         switch(type)
12459                         {
12460                         case 1: v(var.as<E_RABs_Admitted_ToReleased_SgNBModAck_Item>()); return true;
12461                         }
12462                         return false;
12463
12464                 }
12465                 private:
12466                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
12467                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
12468                 union union_type
12469                 {
12470                         char dummy1[sizeof(E_RABs_Admitted_ToReleased_SgNBModAck_Item)];
12471
12472                 };
12473                 asn::variant<sizeof(union_type)> var;
12474                 size_t type {0};
12475
12476         };
12477         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
12478         {
12479                 size_t get_index() const {return type;}
12480                 void clear() {type = 0;}
12481                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAck_Item() { set(mandatory); type=1;}
12482                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
12483                 template<typename V>  bool decode(V& v)
12484                 {
12485                         clear();
12486                         if(!v(ref_nested())) return false;
12487                         if(equal(mandatory)) { type = 1; return true; }
12488                         return false;
12489
12490                 }
12491                 template<typename V> bool encode(V& v) const
12492                 {
12493                         return v(ref_nested());
12494
12495                 }
12496                 protected:
12497                 template<typename V>  bool decode(size_t index, V& v)
12498                 {
12499                         clear();
12500                         switch(index)
12501                         {
12502                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
12503                         ref_nested().clear();
12504                         }
12505                         return false;
12506
12507                 }
12508                 template<typename V> bool encode(size_t index, V& v) const
12509                 {
12510                         if(index != type) {return false;} return v(ref_nested());
12511
12512                 }
12513                 private:
12514                 size_t type {0};
12515
12516         };
12517
12518 };
12519 /*
12520 E-RABs-Admitted-ToBeReleased-SgNBModAckList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBModAck-ItemIEs} }
12521 */
12522
12523 struct E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>
12524 {
12525         static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm";}
12526         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBModAck_ItemIEs>;
12527
12528 };
12529 struct E_RABs_Admitted_ToBeReleased_SgNBModAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>
12530 {
12531         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBModAckList";}
12532         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBModAckList_elm>;
12533         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
12534
12535 };
12536 /*
12537 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12538         ...
12539 }
12540 */
12541
12542 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs
12543 {
12544         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12545         {
12546                 size_t get_index() const {return type;}
12547                 bool is_unknown() const { return type == 1; }
12548                 void clear() {type = 0;}
12549                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12550                 template<typename V>  bool decode(V& v)
12551                 {
12552                         clear();
12553                         if(!v(ref_nested())) return false;
12554                         { type = 1; return true;}
12555                         return false;
12556
12557                 }
12558                 template<typename V> bool encode(V& v) const
12559                 {
12560                         return v(ref_nested());
12561
12562                 }
12563                 protected:
12564                 template<typename V>  bool decode(size_t index, V& v)
12565                 {
12566                         clear();
12567                         switch(index)
12568                         {
12569                         case 1: type = 1; return v(ref_nested());
12570                         ref_nested().clear();
12571                         }
12572                         return false;
12573
12574                 }
12575                 template<typename V> bool encode(size_t index, V& v) const
12576                 {
12577                         if(index != type) {return false;} return v(ref_nested());
12578
12579                 }
12580                 private:
12581                 size_t type {0};
12582
12583         };
12584         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12585         {
12586                 size_t get_index() const {return type;}
12587                 bool is_unknown() const { return type == 1; }
12588                 void clear() {type = 0;}
12589                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12590                 template<typename V>  bool decode(V& v)
12591                 {
12592                         clear();
12593                         if(!v(ref_nested())) return false;
12594                         { type = 1; return true;}
12595                         return false;
12596
12597                 }
12598                 template<typename V> bool encode(V& v) const
12599                 {
12600                         return v(ref_nested());
12601
12602                 }
12603                 protected:
12604                 template<typename V>  bool decode(size_t index, V& v)
12605                 {
12606                         clear();
12607                         switch(index)
12608                         {
12609                         case 1: type = 1; return v(ref_nested());
12610                         ref_nested().clear();
12611                         }
12612                         return false;
12613
12614                 }
12615                 template<typename V> bool encode(size_t index, V& v) const
12616                 {
12617                         if(index != type) {return false;} return v(ref_nested());
12618
12619                 }
12620                 private:
12621                 size_t type {0};
12622
12623         };
12624         struct Extension_t : asn::typefield<true>
12625         {
12626                 ~Extension_t()  {clear();}
12627                 size_t get_index() const {return type;}
12628                 bool is_unknown() const { return type == 1; }
12629                 void clear()
12630                 {
12631                         type = 0; ref_nested().clear();
12632                 }
12633                 template<typename V> static inline void enumerate(V& v)
12634                 {
12635
12636                 }
12637                 protected:
12638                 template<typename V> bool decode(size_t index, V& v)
12639                 {
12640                         clear();
12641                         switch(index)
12642                         {
12643                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12644                         }
12645                         return false;
12646
12647                 }
12648                 template<typename V> bool encode(size_t index, V& v) const
12649                 {
12650                         if(index != type) return false;
12651                         return false;
12652
12653                 }
12654                 private:
12655                 size_t type {0};
12656
12657         };
12658         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12659         {
12660                 size_t get_index() const {return type;}
12661                 bool is_unknown() const { return type == 1; }
12662                 void clear() {type = 0;}
12663                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12664                 template<typename V>  bool decode(V& v)
12665                 {
12666                         clear();
12667                         if(!v(ref_nested())) return false;
12668                         { type = 1; return true;}
12669                         return false;
12670
12671                 }
12672                 template<typename V> bool encode(V& v) const
12673                 {
12674                         return v(ref_nested());
12675
12676                 }
12677                 protected:
12678                 template<typename V>  bool decode(size_t index, V& v)
12679                 {
12680                         clear();
12681                         switch(index)
12682                         {
12683                         case 1: type = 1; return v(ref_nested());
12684                         ref_nested().clear();
12685                         }
12686                         return false;
12687
12688                 }
12689                 template<typename V> bool encode(size_t index, V& v) const
12690                 {
12691                         if(index != type) {return false;} return v(ref_nested());
12692
12693                 }
12694                 private:
12695                 size_t type {0};
12696
12697         };
12698
12699 };
12700 /*
12701 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item ::= SEQUENCE {
12702         e-RAB-ID                                                        E-RAB-ID,
12703         rlc-Mode-transferred                    RLCMode,
12704         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemExtIEs} }  OPTIONAL,
12705         ...
12706 }
12707 */
12708
12709 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item : asn::sequence<3, 0, true, 1>
12710 {
12711         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item";}
12712         using parent_t = asn::sequence<3, 0, true, 1>;
12713         struct e_RAB_ID_t : E_RAB_ID
12714         {
12715                 static constexpr const char* name() {return "e_RAB_ID_t";}
12716                 using parent_t = E_RAB_ID;
12717
12718         };
12719         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
12720         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
12721         struct rlc_Mode_transferred_t : RLCMode
12722         {
12723                 static constexpr const char* name() {return "rlc_Mode_transferred_t";}
12724                 using parent_t = RLCMode;
12725
12726         };
12727         rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
12728         rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
12729         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>
12730         {
12731                 static constexpr const char* name() {return "iE_Extensions_t";}
12732                 using parent_t = ProtocolExtensionContainer<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemExtIEs>;
12733                 static constexpr bool optional = true;
12734
12735         };
12736         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12737         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12738         template<typename V> void decode(V& v)
12739         {
12740                 v(e_RAB_ID);
12741                 v(rlc_Mode_transferred);
12742                 v(iE_Extensions);
12743
12744         };
12745         template<typename V> void encode(V& v) const
12746         {
12747                 v(e_RAB_ID);
12748                 v(rlc_Mode_transferred);
12749                 v(iE_Extensions);
12750
12751         };
12752         void clear()
12753         {
12754                 e_RAB_ID.clear();
12755                 rlc_Mode_transferred.clear();
12756                 iE_Extensions.clear();
12757
12758         };
12759         private:
12760         e_RAB_ID_t      e_RAB_ID;
12761         rlc_Mode_transferred_t  rlc_Mode_transferred;
12762         iE_Extensions_t iE_Extensions;
12763
12764 };
12765 /*
12766 E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs X2AP-PROTOCOL-IES ::= {
12767         { ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-Item            PRESENCE mandatory},
12768         ...
12769 }
12770 */
12771
12772 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs
12773 {
12774         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
12775         {
12776                 size_t get_index() const {return type;}
12777                 bool is_unknown() const { return type == 2; }
12778                 void clear() {type = 0;}
12779                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item); type=1;}
12780                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
12781                 template<typename V>  bool decode(V& v)
12782                 {
12783                         clear();
12784                         if(!v(ref_nested())) return false;
12785                         if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item)) { type = 1; return true; }
12786                         else { type = 2; return true;}
12787                         return false;
12788
12789                 }
12790                 template<typename V> bool encode(V& v) const
12791                 {
12792                         return v(ref_nested());
12793
12794                 }
12795                 protected:
12796                 template<typename V>  bool decode(size_t index, V& v)
12797                 {
12798                         clear();
12799                         switch(index)
12800                         {
12801                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item);} return false;
12802                         case 2: type = 2; return v(ref_nested());
12803                         ref_nested().clear();
12804                         }
12805                         return false;
12806
12807                 }
12808                 template<typename V> bool encode(size_t index, V& v) const
12809                 {
12810                         if(index != type) {return false;} return v(ref_nested());
12811
12812                 }
12813                 private:
12814                 size_t type {0};
12815
12816         };
12817         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
12818         {
12819                 size_t get_index() const {return type;}
12820                 bool is_unknown() const { return type == 2; }
12821                 void clear() {type = 0;}
12822                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(ignore); type=1;}
12823                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
12824                 template<typename V>  bool decode(V& v)
12825                 {
12826                         clear();
12827                         if(!v(ref_nested())) return false;
12828                         if(equal(ignore)) { type = 1; return true; }
12829                         else { type = 2; return true;}
12830                         return false;
12831
12832                 }
12833                 template<typename V> bool encode(V& v) const
12834                 {
12835                         return v(ref_nested());
12836
12837                 }
12838                 protected:
12839                 template<typename V>  bool decode(size_t index, V& v)
12840                 {
12841                         clear();
12842                         switch(index)
12843                         {
12844                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
12845                         case 2: type = 2; return v(ref_nested());
12846                         ref_nested().clear();
12847                         }
12848                         return false;
12849
12850                 }
12851                 template<typename V> bool encode(size_t index, V& v) const
12852                 {
12853                         if(index != type) {return false;} return v(ref_nested());
12854
12855                 }
12856                 private:
12857                 size_t type {0};
12858
12859         };
12860         struct Value_t : asn::typefield<true>
12861         {
12862                 ~Value_t()      {clear();}
12863                 size_t get_index() const {return type;}
12864                 E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
12865                 E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1); }
12866                 bool is_unknown() const { return type == 2; }
12867                 void clear()
12868                 {
12869                         switch(type)
12870                         {
12871                         case 1: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(); break;
12872                         }
12873                         type = 0; ref_nested().clear();
12874                 }
12875                 template<typename V> static inline void enumerate(V& v)
12876                 {
12877                         v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>(1);
12878
12879                 }
12880                 protected:
12881                 template<typename V> bool decode(size_t index, V& v)
12882                 {
12883                         clear();
12884                         switch(index)
12885                         {
12886                         case 1: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item()); return true;
12887                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
12888                         }
12889                         return false;
12890
12891                 }
12892                 template<typename V> bool encode(size_t index, V& v) const
12893                 {
12894                         if(index != type) return false;
12895                         switch(type)
12896                         {
12897                         case 1: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item>()); return true;
12898                         }
12899                         return false;
12900
12901                 }
12902                 private:
12903                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
12904                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
12905                 union union_type
12906                 {
12907                         char dummy1[sizeof(E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item)];
12908
12909                 };
12910                 asn::variant<sizeof(union_type)> var;
12911                 size_t type {0};
12912
12913         };
12914         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
12915         {
12916                 size_t get_index() const {return type;}
12917                 bool is_unknown() const { return type == 2; }
12918                 void clear() {type = 0;}
12919                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_Item() { set(mandatory); type=1;}
12920                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
12921                 template<typename V>  bool decode(V& v)
12922                 {
12923                         clear();
12924                         if(!v(ref_nested())) return false;
12925                         if(equal(mandatory)) { type = 1; return true; }
12926                         else { type = 2; return true;}
12927                         return false;
12928
12929                 }
12930                 template<typename V> bool encode(V& v) const
12931                 {
12932                         return v(ref_nested());
12933
12934                 }
12935                 protected:
12936                 template<typename V>  bool decode(size_t index, V& v)
12937                 {
12938                         clear();
12939                         switch(index)
12940                         {
12941                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
12942                         case 2: type = 2; return v(ref_nested());
12943                         ref_nested().clear();
12944                         }
12945                         return false;
12946
12947                 }
12948                 template<typename V> bool encode(size_t index, V& v) const
12949                 {
12950                         if(index != type) {return false;} return v(ref_nested());
12951
12952                 }
12953                 private:
12954                 size_t type {0};
12955
12956         };
12957
12958 };
12959 /*
12960 E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF
12961                                                                                 ProtocolIE-Single-Container { {E-RABs-Admitted-ToBeReleased-SgNBRelReqAck-ItemIEs} }
12962 */
12963
12964 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm : ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>
12965 {
12966         static constexpr const char* name() {return "E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm";}
12967         using parent_t = ProtocolIE_Single_Container<E_RABs_Admitted_ToBeReleased_SgNBRelReqAck_ItemIEs>;
12968
12969 };
12970 struct E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList : asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>
12971 {
12972         static constexpr const char* name() {return "E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList";}
12973         using parent_t = asn::sequenceof<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList_elm>;
12974         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
12975
12976 };
12977 /*
12978 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12979         ...
12980 }
12981 */
12982
12983 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs
12984 {
12985         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12986         {
12987                 size_t get_index() const {return type;}
12988                 bool is_unknown() const { return type == 1; }
12989                 void clear() {type = 0;}
12990                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12991                 template<typename V>  bool decode(V& v)
12992                 {
12993                         clear();
12994                         if(!v(ref_nested())) return false;
12995                         { type = 1; return true;}
12996                         return false;
12997
12998                 }
12999                 template<typename V> bool encode(V& v) const
13000                 {
13001                         return v(ref_nested());
13002
13003                 }
13004                 protected:
13005                 template<typename V>  bool decode(size_t index, V& v)
13006                 {
13007                         clear();
13008                         switch(index)
13009                         {
13010                         case 1: type = 1; return v(ref_nested());
13011                         ref_nested().clear();
13012                         }
13013                         return false;
13014
13015                 }
13016                 template<typename V> bool encode(size_t index, V& v) const
13017                 {
13018                         if(index != type) {return false;} return v(ref_nested());
13019
13020                 }
13021                 private:
13022                 size_t type {0};
13023
13024         };
13025         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13026         {
13027                 size_t get_index() const {return type;}
13028                 bool is_unknown() const { return type == 1; }
13029                 void clear() {type = 0;}
13030                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13031                 template<typename V>  bool decode(V& v)
13032                 {
13033                         clear();
13034                         if(!v(ref_nested())) return false;
13035                         { type = 1; return true;}
13036                         return false;
13037
13038                 }
13039                 template<typename V> bool encode(V& v) const
13040                 {
13041                         return v(ref_nested());
13042
13043                 }
13044                 protected:
13045                 template<typename V>  bool decode(size_t index, V& v)
13046                 {
13047                         clear();
13048                         switch(index)
13049                         {
13050                         case 1: type = 1; return v(ref_nested());
13051                         ref_nested().clear();
13052                         }
13053                         return false;
13054
13055                 }
13056                 template<typename V> bool encode(size_t index, V& v) const
13057                 {
13058                         if(index != type) {return false;} return v(ref_nested());
13059
13060                 }
13061                 private:
13062                 size_t type {0};
13063
13064         };
13065         struct Extension_t : asn::typefield<true>
13066         {
13067                 ~Extension_t()  {clear();}
13068                 size_t get_index() const {return type;}
13069                 bool is_unknown() const { return type == 1; }
13070                 void clear()
13071                 {
13072                         type = 0; ref_nested().clear();
13073                 }
13074                 template<typename V> static inline void enumerate(V& v)
13075                 {
13076
13077                 }
13078                 protected:
13079                 template<typename V> bool decode(size_t index, V& v)
13080                 {
13081                         clear();
13082                         switch(index)
13083                         {
13084                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13085                         }
13086                         return false;
13087
13088                 }
13089                 template<typename V> bool encode(size_t index, V& v) const
13090                 {
13091                         if(index != type) return false;
13092                         return false;
13093
13094                 }
13095                 private:
13096                 size_t type {0};
13097
13098         };
13099         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13100         {
13101                 size_t get_index() const {return type;}
13102                 bool is_unknown() const { return type == 1; }
13103                 void clear() {type = 0;}
13104                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13105                 template<typename V>  bool decode(V& v)
13106                 {
13107                         clear();
13108                         if(!v(ref_nested())) return false;
13109                         { type = 1; return true;}
13110                         return false;
13111
13112                 }
13113                 template<typename V> bool encode(V& v) const
13114                 {
13115                         return v(ref_nested());
13116
13117                 }
13118                 protected:
13119                 template<typename V>  bool decode(size_t index, V& v)
13120                 {
13121                         clear();
13122                         switch(index)
13123                         {
13124                         case 1: type = 1; return v(ref_nested());
13125                         ref_nested().clear();
13126                         }
13127                         return false;
13128
13129                 }
13130                 template<typename V> bool encode(size_t index, V& v) const
13131                 {
13132                         if(index != type) {return false;} return v(ref_nested());
13133
13134                 }
13135                 private:
13136                 size_t type {0};
13137
13138         };
13139
13140 };
13141 /*
13142 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent ::= SEQUENCE {
13143         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresentExtIEs} }             OPTIONAL,
13144         ...
13145 }
13146 */
13147
13148 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent : asn::sequence<1, 0, true, 1>
13149 {
13150         static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent";}
13151         using parent_t = asn::sequence<1, 0, true, 1>;
13152         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>
13153         {
13154                 static constexpr const char* name() {return "iE_Extensions_t";}
13155                 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresentExtIEs>;
13156                 static constexpr bool optional = true;
13157
13158         };
13159         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13160         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13161         template<typename V> void decode(V& v)
13162         {
13163                 v(iE_Extensions);
13164
13165         };
13166         template<typename V> void encode(V& v) const
13167         {
13168                 v(iE_Extensions);
13169
13170         };
13171         void clear()
13172         {
13173                 iE_Extensions.clear();
13174
13175         };
13176         private:
13177         iE_Extensions_t iE_Extensions;
13178
13179 };
13180 /*
13181 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13182         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
13183         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional},
13184         ...
13185 }
13186 */
13187
13188 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs
13189 {
13190         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13191         {
13192                 size_t get_index() const {return type;}
13193                 bool is_unknown() const { return type == 3; }
13194                 void clear() {type = 0;}
13195                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
13196                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
13197                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13198                 template<typename V>  bool decode(V& v)
13199                 {
13200                         clear();
13201                         if(!v(ref_nested())) return false;
13202                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
13203                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
13204                         else { type = 3; return true;}
13205                         return false;
13206
13207                 }
13208                 template<typename V> bool encode(V& v) const
13209                 {
13210                         return v(ref_nested());
13211
13212                 }
13213                 protected:
13214                 template<typename V>  bool decode(size_t index, V& v)
13215                 {
13216                         clear();
13217                         switch(index)
13218                         {
13219                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
13220                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
13221                         case 3: type = 3; return v(ref_nested());
13222                         ref_nested().clear();
13223                         }
13224                         return false;
13225
13226                 }
13227                 template<typename V> bool encode(size_t index, V& v) const
13228                 {
13229                         if(index != type) {return false;} return v(ref_nested());
13230
13231                 }
13232                 private:
13233                 size_t type {0};
13234
13235         };
13236         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13237         {
13238                 size_t get_index() const {return type;}
13239                 bool is_unknown() const { return type == 3; }
13240                 void clear() {type = 0;}
13241                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
13242                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
13243                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13244                 template<typename V>  bool decode(V& v)
13245                 {
13246                         clear();
13247                         if(!v(ref_nested())) return false;
13248                         if(equal(ignore)) { type = 1; return true; }
13249                         else if(equal(ignore)) { type = 2; return true; }
13250                         else { type = 3; return true;}
13251                         return false;
13252
13253                 }
13254                 template<typename V> bool encode(V& v) const
13255                 {
13256                         return v(ref_nested());
13257
13258                 }
13259                 protected:
13260                 template<typename V>  bool decode(size_t index, V& v)
13261                 {
13262                         clear();
13263                         switch(index)
13264                         {
13265                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13266                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
13267                         case 3: type = 3; return v(ref_nested());
13268                         ref_nested().clear();
13269                         }
13270                         return false;
13271
13272                 }
13273                 template<typename V> bool encode(size_t index, V& v) const
13274                 {
13275                         if(index != type) {return false;} return v(ref_nested());
13276
13277                 }
13278                 private:
13279                 size_t type {0};
13280
13281         };
13282         struct Extension_t : asn::typefield<true>
13283         {
13284                 ~Extension_t()  {clear();}
13285                 size_t get_index() const {return type;}
13286                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
13287                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
13288                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
13289                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
13290                 bool is_unknown() const { return type == 3; }
13291                 void clear()
13292                 {
13293                         switch(type)
13294                         {
13295                         case 1: var.destroy<PDCPSnLength>(); break;
13296                         case 2: var.destroy<PDCPSnLength>(); break;
13297                         }
13298                         type = 0; ref_nested().clear();
13299                 }
13300                 template<typename V> static inline void enumerate(V& v)
13301                 {
13302                         v.template operator()<PDCPSnLength>(1);
13303                         v.template operator()<PDCPSnLength>(2);
13304
13305                 }
13306                 protected:
13307                 template<typename V> bool decode(size_t index, V& v)
13308                 {
13309                         clear();
13310                         switch(index)
13311                         {
13312                         case 1: v(select_id_uLpDCPSnLength()); return true;
13313                         case 2: v(select_id_dLPDCPSnLength()); return true;
13314                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
13315                         }
13316                         return false;
13317
13318                 }
13319                 template<typename V> bool encode(size_t index, V& v) const
13320                 {
13321                         if(index != type) return false;
13322                         switch(type)
13323                         {
13324                         case 1: v(var.as<PDCPSnLength>()); return true;
13325                         case 2: v(var.as<PDCPSnLength>()); return true;
13326                         }
13327                         return false;
13328
13329                 }
13330                 private:
13331                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13332                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13333                 union union_type
13334                 {
13335                         char dummy1[sizeof(PDCPSnLength)];
13336
13337                 };
13338                 asn::variant<sizeof(union_type)> var;
13339                 size_t type {0};
13340
13341         };
13342         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13343         {
13344                 size_t get_index() const {return type;}
13345                 bool is_unknown() const { return type == 3; }
13346                 void clear() {type = 0;}
13347                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
13348                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
13349                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13350                 template<typename V>  bool decode(V& v)
13351                 {
13352                         clear();
13353                         if(!v(ref_nested())) return false;
13354                         if(equal(optional)) { type = 1; return true; }
13355                         else if(equal(optional)) { type = 2; return true; }
13356                         else { type = 3; return true;}
13357                         return false;
13358
13359                 }
13360                 template<typename V> bool encode(V& v) const
13361                 {
13362                         return v(ref_nested());
13363
13364                 }
13365                 protected:
13366                 template<typename V>  bool decode(size_t index, V& v)
13367                 {
13368                         clear();
13369                         switch(index)
13370                         {
13371                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
13372                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
13373                         case 3: type = 3; return v(ref_nested());
13374                         ref_nested().clear();
13375                         }
13376                         return false;
13377
13378                 }
13379                 template<typename V> bool encode(size_t index, V& v) const
13380                 {
13381                         if(index != type) {return false;} return v(ref_nested());
13382
13383                 }
13384                 private:
13385                 size_t type {0};
13386
13387         };
13388
13389 };
13390 /*
13391 E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
13392         secondary-meNB-UL-GTP-TEIDatPDCP                                GTPtunnelEndpoint                               OPTIONAL,
13393         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresentExtIEs} }          OPTIONAL,
13394         ...
13395 }
13396 */
13397
13398 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent : asn::sequence<2, 0, true, 2>
13399 {
13400         static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent";}
13401         using parent_t = asn::sequence<2, 0, true, 2>;
13402         struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
13403         {
13404                 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
13405                 using parent_t = GTPtunnelEndpoint;
13406                 static constexpr bool optional = true;
13407
13408         };
13409         secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
13410         secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
13411         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>
13412         {
13413                 static constexpr const char* name() {return "iE_Extensions_t";}
13414                 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresentExtIEs>;
13415                 static constexpr bool optional = true;
13416
13417         };
13418         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13419         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13420         template<typename V> void decode(V& v)
13421         {
13422                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
13423                 v(iE_Extensions);
13424
13425         };
13426         template<typename V> void encode(V& v) const
13427         {
13428                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
13429                 v(iE_Extensions);
13430
13431         };
13432         void clear()
13433         {
13434                 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
13435                 iE_Extensions.clear();
13436
13437         };
13438         private:
13439         secondary_meNB_UL_GTP_TEIDatPDCP_t      secondary_meNB_UL_GTP_TEIDatPDCP;
13440         iE_Extensions_t iE_Extensions;
13441
13442 };
13443 /*
13444 E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13445         ...
13446 }
13447 */
13448
13449 struct E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs
13450 {
13451         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13452         {
13453                 size_t get_index() const {return type;}
13454                 bool is_unknown() const { return type == 1; }
13455                 void clear() {type = 0;}
13456                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13457                 template<typename V>  bool decode(V& v)
13458                 {
13459                         clear();
13460                         if(!v(ref_nested())) return false;
13461                         { type = 1; return true;}
13462                         return false;
13463
13464                 }
13465                 template<typename V> bool encode(V& v) const
13466                 {
13467                         return v(ref_nested());
13468
13469                 }
13470                 protected:
13471                 template<typename V>  bool decode(size_t index, V& v)
13472                 {
13473                         clear();
13474                         switch(index)
13475                         {
13476                         case 1: type = 1; return v(ref_nested());
13477                         ref_nested().clear();
13478                         }
13479                         return false;
13480
13481                 }
13482                 template<typename V> bool encode(size_t index, V& v) const
13483                 {
13484                         if(index != type) {return false;} return v(ref_nested());
13485
13486                 }
13487                 private:
13488                 size_t type {0};
13489
13490         };
13491         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13492         {
13493                 size_t get_index() const {return type;}
13494                 bool is_unknown() const { return type == 1; }
13495                 void clear() {type = 0;}
13496                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13497                 template<typename V>  bool decode(V& v)
13498                 {
13499                         clear();
13500                         if(!v(ref_nested())) return false;
13501                         { type = 1; return true;}
13502                         return false;
13503
13504                 }
13505                 template<typename V> bool encode(V& v) const
13506                 {
13507                         return v(ref_nested());
13508
13509                 }
13510                 protected:
13511                 template<typename V>  bool decode(size_t index, V& v)
13512                 {
13513                         clear();
13514                         switch(index)
13515                         {
13516                         case 1: type = 1; return v(ref_nested());
13517                         ref_nested().clear();
13518                         }
13519                         return false;
13520
13521                 }
13522                 template<typename V> bool encode(size_t index, V& v) const
13523                 {
13524                         if(index != type) {return false;} return v(ref_nested());
13525
13526                 }
13527                 private:
13528                 size_t type {0};
13529
13530         };
13531         struct Extension_t : asn::typefield<true>
13532         {
13533                 ~Extension_t()  {clear();}
13534                 size_t get_index() const {return type;}
13535                 bool is_unknown() const { return type == 1; }
13536                 void clear()
13537                 {
13538                         type = 0; ref_nested().clear();
13539                 }
13540                 template<typename V> static inline void enumerate(V& v)
13541                 {
13542
13543                 }
13544                 protected:
13545                 template<typename V> bool decode(size_t index, V& v)
13546                 {
13547                         clear();
13548                         switch(index)
13549                         {
13550                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13551                         }
13552                         return false;
13553
13554                 }
13555                 template<typename V> bool encode(size_t index, V& v) const
13556                 {
13557                         if(index != type) return false;
13558                         return false;
13559
13560                 }
13561                 private:
13562                 size_t type {0};
13563
13564         };
13565         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13566         {
13567                 size_t get_index() const {return type;}
13568                 bool is_unknown() const { return type == 1; }
13569                 void clear() {type = 0;}
13570                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13571                 template<typename V>  bool decode(V& v)
13572                 {
13573                         clear();
13574                         if(!v(ref_nested())) return false;
13575                         { type = 1; return true;}
13576                         return false;
13577
13578                 }
13579                 template<typename V> bool encode(V& v) const
13580                 {
13581                         return v(ref_nested());
13582
13583                 }
13584                 protected:
13585                 template<typename V>  bool decode(size_t index, V& v)
13586                 {
13587                         clear();
13588                         switch(index)
13589                         {
13590                         case 1: type = 1; return v(ref_nested());
13591                         ref_nested().clear();
13592                         }
13593                         return false;
13594
13595                 }
13596                 template<typename V> bool encode(size_t index, V& v) const
13597                 {
13598                         if(index != type) {return false;} return v(ref_nested());
13599
13600                 }
13601                 private:
13602                 size_t type {0};
13603
13604         };
13605
13606 };
13607 /*
13608 E-RABs-AdmittedToBeModified-SgNBModConf-Item ::= SEQUENCE {
13609         e-RAB-ID                                                                E-RAB-ID,
13610         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
13611         resource-configuration                          CHOICE {
13612                 sgNBPDCPpresent                                         E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPpresent,
13613                 sgNBPDCPnotpresent                                      E-RABs-AdmittedToBeModified-SgNBModConf-Item-SgNBPDCPnotpresent,
13614                 ...
13615         },
13616         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-AdmittedToBeModified-SgNBModConf-ItemExtIEs} }     OPTIONAL,
13617         ...
13618 }
13619 */
13620
13621 struct E_RABs_AdmittedToBeModified_SgNBModConf_Item : asn::sequence<4, 0, true, 1>
13622 {
13623         static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConf-Item";}
13624         using parent_t = asn::sequence<4, 0, true, 1>;
13625         struct e_RAB_ID_t : E_RAB_ID
13626         {
13627                 static constexpr const char* name() {return "e_RAB_ID_t";}
13628                 using parent_t = E_RAB_ID;
13629
13630         };
13631         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
13632         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
13633         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
13634         {
13635                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
13636                 using parent_t = EN_DC_ResourceConfiguration;
13637
13638         };
13639         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
13640         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
13641         struct resource_configuration_t : asn::choice<2, 0, true>
13642         {
13643                 static constexpr const char* name() {return "resource_configuration_t";}
13644                 using parent_t = asn::choice<2, 0, true>;
13645                 index_type get_index() const {return index;}
13646                 bool is_unknown() const {return index == 3;}
13647                 void set_unknown() { set_index(3);  }
13648                 ~resource_configuration_t() {clear();}
13649                 struct sgNBPDCPpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent
13650                 {
13651                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
13652                         using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPpresent;
13653
13654                 };
13655                 struct sgNBPDCPnotpresent_t : E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent
13656                 {
13657                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
13658                         using parent_t = E_RABs_AdmittedToBeModified_SgNBModConf_Item_SgNBPDCPnotpresent;
13659
13660                 };
13661                 void clear()
13662                 {
13663                         switch(get_index())
13664                         {
13665                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
13666                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
13667                         }
13668                         index = 0;
13669                         base::clear();
13670                 }
13671                 template<typename V> bool decode(size_t idx, V& v)
13672                 {
13673                         clear();
13674                         switch(idx)
13675                         {
13676                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
13677                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
13678                         }
13679                         return false;
13680
13681                 }
13682                 template<typename V> bool encode(V& v) const
13683                 {
13684                         switch(get_index())
13685                         {
13686                         case 1: return v(var.as<sgNBPDCPpresent_t>());
13687                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
13688                         }
13689                         return false;
13690                 }
13691                 template<typename V> static inline void enumerate(V& v)
13692                 {
13693                         v.template operator()<sgNBPDCPpresent_t>(1);
13694                         v.template operator()<sgNBPDCPnotpresent_t>(2);
13695
13696                 }
13697                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
13698                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
13699                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
13700                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
13701                 private:
13702                 void set_index(index_type i) {index = i; base::set();}
13703                 union union_type
13704                 {
13705                         char dummy1[sizeof(sgNBPDCPpresent_t)];
13706                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
13707
13708                 };
13709                 asn::variant<sizeof(union_type)>        var;
13710                 index_type      index {0};
13711         };
13712         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
13713         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
13714         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>
13715         {
13716                 static constexpr const char* name() {return "iE_Extensions_t";}
13717                 using parent_t = ProtocolExtensionContainer<E_RABs_AdmittedToBeModified_SgNBModConf_ItemExtIEs>;
13718                 static constexpr bool optional = true;
13719
13720         };
13721         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13722         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13723         template<typename V> void decode(V& v)
13724         {
13725                 v(e_RAB_ID);
13726                 v(en_DC_ResourceConfiguration);
13727                 v(resource_configuration);
13728                 v(iE_Extensions);
13729
13730         };
13731         template<typename V> void encode(V& v) const
13732         {
13733                 v(e_RAB_ID);
13734                 v(en_DC_ResourceConfiguration);
13735                 v(resource_configuration);
13736                 v(iE_Extensions);
13737
13738         };
13739         void clear()
13740         {
13741                 e_RAB_ID.clear();
13742                 en_DC_ResourceConfiguration.clear();
13743                 resource_configuration.clear();
13744                 iE_Extensions.clear();
13745
13746         };
13747         private:
13748         e_RAB_ID_t      e_RAB_ID;
13749         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
13750         resource_configuration_t        resource_configuration;
13751         iE_Extensions_t iE_Extensions;
13752
13753 };
13754 /*
13755 E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs X2AP-PROTOCOL-IES ::= {
13756 { ID id-E-RABs-AdmittedToBeModified-SgNBModConf-Item     CRITICALITY ignore     TYPE E-RABs-AdmittedToBeModified-SgNBModConf-Item        PRESENCE mandatory },
13757         ...
13758 }
13759 */
13760
13761 struct E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs
13762 {
13763         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
13764         {
13765                 size_t get_index() const {return type;}
13766                 bool is_unknown() const { return type == 2; }
13767                 void clear() {type = 0;}
13768                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item); type=1;}
13769                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
13770                 template<typename V>  bool decode(V& v)
13771                 {
13772                         clear();
13773                         if(!v(ref_nested())) return false;
13774                         if(equal(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item)) { type = 1; return true; }
13775                         else { type = 2; return true;}
13776                         return false;
13777
13778                 }
13779                 template<typename V> bool encode(V& v) const
13780                 {
13781                         return v(ref_nested());
13782
13783                 }
13784                 protected:
13785                 template<typename V>  bool decode(size_t index, V& v)
13786                 {
13787                         clear();
13788                         switch(index)
13789                         {
13790                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_AdmittedToBeModified_SgNBModConf_Item);} return false;
13791                         case 2: type = 2; return v(ref_nested());
13792                         ref_nested().clear();
13793                         }
13794                         return false;
13795
13796                 }
13797                 template<typename V> bool encode(size_t index, V& v) const
13798                 {
13799                         if(index != type) {return false;} return v(ref_nested());
13800
13801                 }
13802                 private:
13803                 size_t type {0};
13804
13805         };
13806         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
13807         {
13808                 size_t get_index() const {return type;}
13809                 bool is_unknown() const { return type == 2; }
13810                 void clear() {type = 0;}
13811                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(ignore); type=1;}
13812                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
13813                 template<typename V>  bool decode(V& v)
13814                 {
13815                         clear();
13816                         if(!v(ref_nested())) return false;
13817                         if(equal(ignore)) { type = 1; return true; }
13818                         else { type = 2; return true;}
13819                         return false;
13820
13821                 }
13822                 template<typename V> bool encode(V& v) const
13823                 {
13824                         return v(ref_nested());
13825
13826                 }
13827                 protected:
13828                 template<typename V>  bool decode(size_t index, V& v)
13829                 {
13830                         clear();
13831                         switch(index)
13832                         {
13833                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13834                         case 2: type = 2; return v(ref_nested());
13835                         ref_nested().clear();
13836                         }
13837                         return false;
13838
13839                 }
13840                 template<typename V> bool encode(size_t index, V& v) const
13841                 {
13842                         if(index != type) {return false;} return v(ref_nested());
13843
13844                 }
13845                 private:
13846                 size_t type {0};
13847
13848         };
13849         struct Value_t : asn::typefield<true>
13850         {
13851                 ~Value_t()      {clear();}
13852                 size_t get_index() const {return type;}
13853                 E_RABs_AdmittedToBeModified_SgNBModConf_Item& select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { return set<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
13854                 E_RABs_AdmittedToBeModified_SgNBModConf_Item const* get_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() const { return get<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1); }
13855                 bool is_unknown() const { return type == 2; }
13856                 void clear()
13857                 {
13858                         switch(type)
13859                         {
13860                         case 1: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(); break;
13861                         }
13862                         type = 0; ref_nested().clear();
13863                 }
13864                 template<typename V> static inline void enumerate(V& v)
13865                 {
13866                         v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConf_Item>(1);
13867
13868                 }
13869                 protected:
13870                 template<typename V> bool decode(size_t index, V& v)
13871                 {
13872                         clear();
13873                         switch(index)
13874                         {
13875                         case 1: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item()); return true;
13876                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
13877                         }
13878                         return false;
13879
13880                 }
13881                 template<typename V> bool encode(size_t index, V& v) const
13882                 {
13883                         if(index != type) return false;
13884                         switch(type)
13885                         {
13886                         case 1: v(var.as<E_RABs_AdmittedToBeModified_SgNBModConf_Item>()); return true;
13887                         }
13888                         return false;
13889
13890                 }
13891                 private:
13892                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13893                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13894                 union union_type
13895                 {
13896                         char dummy1[sizeof(E_RABs_AdmittedToBeModified_SgNBModConf_Item)];
13897
13898                 };
13899                 asn::variant<sizeof(union_type)> var;
13900                 size_t type {0};
13901
13902         };
13903         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
13904         {
13905                 size_t get_index() const {return type;}
13906                 bool is_unknown() const { return type == 2; }
13907                 void clear() {type = 0;}
13908                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConf_Item() { set(mandatory); type=1;}
13909                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
13910                 template<typename V>  bool decode(V& v)
13911                 {
13912                         clear();
13913                         if(!v(ref_nested())) return false;
13914                         if(equal(mandatory)) { type = 1; return true; }
13915                         else { type = 2; return true;}
13916                         return false;
13917
13918                 }
13919                 template<typename V> bool encode(V& v) const
13920                 {
13921                         return v(ref_nested());
13922
13923                 }
13924                 protected:
13925                 template<typename V>  bool decode(size_t index, V& v)
13926                 {
13927                         clear();
13928                         switch(index)
13929                         {
13930                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
13931                         case 2: type = 2; return v(ref_nested());
13932                         ref_nested().clear();
13933                         }
13934                         return false;
13935
13936                 }
13937                 template<typename V> bool encode(size_t index, V& v) const
13938                 {
13939                         if(index != type) {return false;} return v(ref_nested());
13940
13941                 }
13942                 private:
13943                 size_t type {0};
13944
13945         };
13946
13947 };
13948 /*
13949 E-RABs-AdmittedToBeModified-SgNBModConfList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container
13950         { {E-RABs-AdmittedToBeModified-SgNBModConf-ItemIEs} }
13951 */
13952
13953 struct E_RABs_AdmittedToBeModified_SgNBModConfList_elm : ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>
13954 {
13955         static constexpr const char* name() {return "E_RABs_AdmittedToBeModified_SgNBModConfList_elm";}
13956         using parent_t = ProtocolIE_Single_Container<E_RABs_AdmittedToBeModified_SgNBModConf_ItemIEs>;
13957
13958 };
13959 struct E_RABs_AdmittedToBeModified_SgNBModConfList : asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>
13960 {
13961         static constexpr const char* name() {return "E-RABs-AdmittedToBeModified-SgNBModConfList";}
13962         using parent_t = asn::sequenceof<E_RABs_AdmittedToBeModified_SgNBModConfList_elm>;
13963         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
13964
13965 };
13966 /*
13967 E-RABs-SubjectToCounterCheckItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13968         ...
13969 }
13970 */
13971
13972 struct E_RABs_SubjectToCounterCheckItemExtIEs
13973 {
13974         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13975         {
13976                 size_t get_index() const {return type;}
13977                 bool is_unknown() const { return type == 1; }
13978                 void clear() {type = 0;}
13979                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13980                 template<typename V>  bool decode(V& v)
13981                 {
13982                         clear();
13983                         if(!v(ref_nested())) return false;
13984                         { type = 1; return true;}
13985                         return false;
13986
13987                 }
13988                 template<typename V> bool encode(V& v) const
13989                 {
13990                         return v(ref_nested());
13991
13992                 }
13993                 protected:
13994                 template<typename V>  bool decode(size_t index, V& v)
13995                 {
13996                         clear();
13997                         switch(index)
13998                         {
13999                         case 1: type = 1; return v(ref_nested());
14000                         ref_nested().clear();
14001                         }
14002                         return false;
14003
14004                 }
14005                 template<typename V> bool encode(size_t index, V& v) const
14006                 {
14007                         if(index != type) {return false;} return v(ref_nested());
14008
14009                 }
14010                 private:
14011                 size_t type {0};
14012
14013         };
14014         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14015         {
14016                 size_t get_index() const {return type;}
14017                 bool is_unknown() const { return type == 1; }
14018                 void clear() {type = 0;}
14019                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14020                 template<typename V>  bool decode(V& v)
14021                 {
14022                         clear();
14023                         if(!v(ref_nested())) return false;
14024                         { type = 1; return true;}
14025                         return false;
14026
14027                 }
14028                 template<typename V> bool encode(V& v) const
14029                 {
14030                         return v(ref_nested());
14031
14032                 }
14033                 protected:
14034                 template<typename V>  bool decode(size_t index, V& v)
14035                 {
14036                         clear();
14037                         switch(index)
14038                         {
14039                         case 1: type = 1; return v(ref_nested());
14040                         ref_nested().clear();
14041                         }
14042                         return false;
14043
14044                 }
14045                 template<typename V> bool encode(size_t index, V& v) const
14046                 {
14047                         if(index != type) {return false;} return v(ref_nested());
14048
14049                 }
14050                 private:
14051                 size_t type {0};
14052
14053         };
14054         struct Extension_t : asn::typefield<true>
14055         {
14056                 ~Extension_t()  {clear();}
14057                 size_t get_index() const {return type;}
14058                 bool is_unknown() const { return type == 1; }
14059                 void clear()
14060                 {
14061                         type = 0; ref_nested().clear();
14062                 }
14063                 template<typename V> static inline void enumerate(V& v)
14064                 {
14065
14066                 }
14067                 protected:
14068                 template<typename V> bool decode(size_t index, V& v)
14069                 {
14070                         clear();
14071                         switch(index)
14072                         {
14073                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14074                         }
14075                         return false;
14076
14077                 }
14078                 template<typename V> bool encode(size_t index, V& v) const
14079                 {
14080                         if(index != type) return false;
14081                         return false;
14082
14083                 }
14084                 private:
14085                 size_t type {0};
14086
14087         };
14088         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14089         {
14090                 size_t get_index() const {return type;}
14091                 bool is_unknown() const { return type == 1; }
14092                 void clear() {type = 0;}
14093                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14094                 template<typename V>  bool decode(V& v)
14095                 {
14096                         clear();
14097                         if(!v(ref_nested())) return false;
14098                         { type = 1; return true;}
14099                         return false;
14100
14101                 }
14102                 template<typename V> bool encode(V& v) const
14103                 {
14104                         return v(ref_nested());
14105
14106                 }
14107                 protected:
14108                 template<typename V>  bool decode(size_t index, V& v)
14109                 {
14110                         clear();
14111                         switch(index)
14112                         {
14113                         case 1: type = 1; return v(ref_nested());
14114                         ref_nested().clear();
14115                         }
14116                         return false;
14117
14118                 }
14119                 template<typename V> bool encode(size_t index, V& v) const
14120                 {
14121                         if(index != type) {return false;} return v(ref_nested());
14122
14123                 }
14124                 private:
14125                 size_t type {0};
14126
14127         };
14128
14129 };
14130 /*
14131 E-RABs-SubjectToCounterCheckItem ::= SEQUENCE {
14132         e-RAB-ID                                                E-RAB-ID,
14133         uL-Count                                                INTEGER (0..4294967295),
14134         dL-Count                                                INTEGER (0..4294967295),
14135         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-SubjectToCounterCheckItemExtIEs} } OPTIONAL,
14136         ...
14137 }
14138 */
14139
14140 struct E_RABs_SubjectToCounterCheckItem : asn::sequence<4, 0, true, 1>
14141 {
14142         static constexpr const char* name() {return "E-RABs-SubjectToCounterCheckItem";}
14143         using parent_t = asn::sequence<4, 0, true, 1>;
14144         struct e_RAB_ID_t : E_RAB_ID
14145         {
14146                 static constexpr const char* name() {return "e_RAB_ID_t";}
14147                 using parent_t = E_RAB_ID;
14148
14149         };
14150         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
14151         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
14152         struct uL_Count_t : asn::integer<>
14153         {
14154                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14155                 static constexpr const char* name() {return "uL_Count_t";}
14156                 using parent_t = asn::integer<>;
14157
14158         };
14159
14160         uL_Count_t& ref_uL_Count() {return uL_Count;}
14161         uL_Count_t const& ref_uL_Count() const {return uL_Count;}
14162         struct dL_Count_t : asn::integer<>
14163         {
14164                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14165                 static constexpr const char* name() {return "dL_Count_t";}
14166                 using parent_t = asn::integer<>;
14167
14168         };
14169
14170         dL_Count_t& ref_dL_Count() {return dL_Count;}
14171         dL_Count_t const& ref_dL_Count() const {return dL_Count;}
14172         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>
14173         {
14174                 static constexpr const char* name() {return "iE_Extensions_t";}
14175                 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToCounterCheckItemExtIEs>;
14176                 static constexpr bool optional = true;
14177
14178         };
14179         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14180         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14181         template<typename V> void decode(V& v)
14182         {
14183                 v(e_RAB_ID);
14184                 v(uL_Count);
14185                 v(dL_Count);
14186                 v(iE_Extensions);
14187
14188         };
14189         template<typename V> void encode(V& v) const
14190         {
14191                 v(e_RAB_ID);
14192                 v(uL_Count);
14193                 v(dL_Count);
14194                 v(iE_Extensions);
14195
14196         };
14197         void clear()
14198         {
14199                 e_RAB_ID.clear();
14200                 uL_Count.clear();
14201                 dL_Count.clear();
14202                 iE_Extensions.clear();
14203
14204         };
14205         private:
14206         e_RAB_ID_t      e_RAB_ID;
14207         uL_Count_t      uL_Count;
14208         dL_Count_t      dL_Count;
14209         iE_Extensions_t iE_Extensions;
14210
14211 };
14212 /*
14213 E-RABs-SubjectToCounterCheckItemIEs X2AP-PROTOCOL-IES ::= {
14214         { ID id-E-RABs-SubjectToCounterCheckItem        CRITICALITY ignore      TYPE E-RABs-SubjectToCounterCheckItem           PRESENCE mandatory},
14215         ...
14216 }
14217 */
14218
14219 struct E_RABs_SubjectToCounterCheckItemIEs
14220 {
14221         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14222         {
14223                 size_t get_index() const {return type;}
14224                 bool is_unknown() const { return type == 2; }
14225                 void clear() {type = 0;}
14226                 void select_id_E_RABs_SubjectToCounterCheckItem() { set(id_E_RABs_SubjectToCounterCheckItem); type=1;}
14227                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14228                 template<typename V>  bool decode(V& v)
14229                 {
14230                         clear();
14231                         if(!v(ref_nested())) return false;
14232                         if(equal(id_E_RABs_SubjectToCounterCheckItem)) { type = 1; return true; }
14233                         else { type = 2; return true;}
14234                         return false;
14235
14236                 }
14237                 template<typename V> bool encode(V& v) const
14238                 {
14239                         return v(ref_nested());
14240
14241                 }
14242                 protected:
14243                 template<typename V>  bool decode(size_t index, V& v)
14244                 {
14245                         clear();
14246                         switch(index)
14247                         {
14248                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToCounterCheckItem);} return false;
14249                         case 2: type = 2; return v(ref_nested());
14250                         ref_nested().clear();
14251                         }
14252                         return false;
14253
14254                 }
14255                 template<typename V> bool encode(size_t index, V& v) const
14256                 {
14257                         if(index != type) {return false;} return v(ref_nested());
14258
14259                 }
14260                 private:
14261                 size_t type {0};
14262
14263         };
14264         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14265         {
14266                 size_t get_index() const {return type;}
14267                 bool is_unknown() const { return type == 2; }
14268                 void clear() {type = 0;}
14269                 void select_id_E_RABs_SubjectToCounterCheckItem() { set(ignore); type=1;}
14270                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14271                 template<typename V>  bool decode(V& v)
14272                 {
14273                         clear();
14274                         if(!v(ref_nested())) return false;
14275                         if(equal(ignore)) { type = 1; return true; }
14276                         else { type = 2; return true;}
14277                         return false;
14278
14279                 }
14280                 template<typename V> bool encode(V& v) const
14281                 {
14282                         return v(ref_nested());
14283
14284                 }
14285                 protected:
14286                 template<typename V>  bool decode(size_t index, V& v)
14287                 {
14288                         clear();
14289                         switch(index)
14290                         {
14291                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14292                         case 2: type = 2; return v(ref_nested());
14293                         ref_nested().clear();
14294                         }
14295                         return false;
14296
14297                 }
14298                 template<typename V> bool encode(size_t index, V& v) const
14299                 {
14300                         if(index != type) {return false;} return v(ref_nested());
14301
14302                 }
14303                 private:
14304                 size_t type {0};
14305
14306         };
14307         struct Value_t : asn::typefield<true>
14308         {
14309                 ~Value_t()      {clear();}
14310                 size_t get_index() const {return type;}
14311                 E_RABs_SubjectToCounterCheckItem& select_id_E_RABs_SubjectToCounterCheckItem() { return set<E_RABs_SubjectToCounterCheckItem>(1); }
14312                 E_RABs_SubjectToCounterCheckItem const* get_id_E_RABs_SubjectToCounterCheckItem() const { return get<E_RABs_SubjectToCounterCheckItem>(1); }
14313                 bool is_unknown() const { return type == 2; }
14314                 void clear()
14315                 {
14316                         switch(type)
14317                         {
14318                         case 1: var.destroy<E_RABs_SubjectToCounterCheckItem>(); break;
14319                         }
14320                         type = 0; ref_nested().clear();
14321                 }
14322                 template<typename V> static inline void enumerate(V& v)
14323                 {
14324                         v.template operator()<E_RABs_SubjectToCounterCheckItem>(1);
14325
14326                 }
14327                 protected:
14328                 template<typename V> bool decode(size_t index, V& v)
14329                 {
14330                         clear();
14331                         switch(index)
14332                         {
14333                         case 1: v(select_id_E_RABs_SubjectToCounterCheckItem()); return true;
14334                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14335                         }
14336                         return false;
14337
14338                 }
14339                 template<typename V> bool encode(size_t index, V& v) const
14340                 {
14341                         if(index != type) return false;
14342                         switch(type)
14343                         {
14344                         case 1: v(var.as<E_RABs_SubjectToCounterCheckItem>()); return true;
14345                         }
14346                         return false;
14347
14348                 }
14349                 private:
14350                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14351                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14352                 union union_type
14353                 {
14354                         char dummy1[sizeof(E_RABs_SubjectToCounterCheckItem)];
14355
14356                 };
14357                 asn::variant<sizeof(union_type)> var;
14358                 size_t type {0};
14359
14360         };
14361         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14362         {
14363                 size_t get_index() const {return type;}
14364                 bool is_unknown() const { return type == 2; }
14365                 void clear() {type = 0;}
14366                 void select_id_E_RABs_SubjectToCounterCheckItem() { set(mandatory); type=1;}
14367                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14368                 template<typename V>  bool decode(V& v)
14369                 {
14370                         clear();
14371                         if(!v(ref_nested())) return false;
14372                         if(equal(mandatory)) { type = 1; return true; }
14373                         else { type = 2; return true;}
14374                         return false;
14375
14376                 }
14377                 template<typename V> bool encode(V& v) const
14378                 {
14379                         return v(ref_nested());
14380
14381                 }
14382                 protected:
14383                 template<typename V>  bool decode(size_t index, V& v)
14384                 {
14385                         clear();
14386                         switch(index)
14387                         {
14388                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14389                         case 2: type = 2; return v(ref_nested());
14390                         ref_nested().clear();
14391                         }
14392                         return false;
14393
14394                 }
14395                 template<typename V> bool encode(size_t index, V& v) const
14396                 {
14397                         if(index != type) {return false;} return v(ref_nested());
14398
14399                 }
14400                 private:
14401                 size_t type {0};
14402
14403         };
14404
14405 };
14406 /*
14407 E-RABs-SubjectToCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToCounterCheckItemIEs} }
14408 */
14409
14410 struct E_RABs_SubjectToCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>
14411 {
14412         static constexpr const char* name() {return "E_RABs_SubjectToCounterCheck_List_elm";}
14413         using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToCounterCheckItemIEs>;
14414
14415 };
14416 struct E_RABs_SubjectToCounterCheck_List : asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>
14417 {
14418         static constexpr const char* name() {return "E-RABs-SubjectToCounterCheck-List";}
14419         using parent_t = asn::sequenceof<E_RABs_SubjectToCounterCheck_List_elm>;
14420         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
14421
14422 };
14423 /*
14424 E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14425         ...
14426 }
14427 */
14428
14429 struct E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs
14430 {
14431         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14432         {
14433                 size_t get_index() const {return type;}
14434                 bool is_unknown() const { return type == 1; }
14435                 void clear() {type = 0;}
14436                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14437                 template<typename V>  bool decode(V& v)
14438                 {
14439                         clear();
14440                         if(!v(ref_nested())) return false;
14441                         { type = 1; return true;}
14442                         return false;
14443
14444                 }
14445                 template<typename V> bool encode(V& v) const
14446                 {
14447                         return v(ref_nested());
14448
14449                 }
14450                 protected:
14451                 template<typename V>  bool decode(size_t index, V& v)
14452                 {
14453                         clear();
14454                         switch(index)
14455                         {
14456                         case 1: type = 1; return v(ref_nested());
14457                         ref_nested().clear();
14458                         }
14459                         return false;
14460
14461                 }
14462                 template<typename V> bool encode(size_t index, V& v) const
14463                 {
14464                         if(index != type) {return false;} return v(ref_nested());
14465
14466                 }
14467                 private:
14468                 size_t type {0};
14469
14470         };
14471         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14472         {
14473                 size_t get_index() const {return type;}
14474                 bool is_unknown() const { return type == 1; }
14475                 void clear() {type = 0;}
14476                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14477                 template<typename V>  bool decode(V& v)
14478                 {
14479                         clear();
14480                         if(!v(ref_nested())) return false;
14481                         { type = 1; return true;}
14482                         return false;
14483
14484                 }
14485                 template<typename V> bool encode(V& v) const
14486                 {
14487                         return v(ref_nested());
14488
14489                 }
14490                 protected:
14491                 template<typename V>  bool decode(size_t index, V& v)
14492                 {
14493                         clear();
14494                         switch(index)
14495                         {
14496                         case 1: type = 1; return v(ref_nested());
14497                         ref_nested().clear();
14498                         }
14499                         return false;
14500
14501                 }
14502                 template<typename V> bool encode(size_t index, V& v) const
14503                 {
14504                         if(index != type) {return false;} return v(ref_nested());
14505
14506                 }
14507                 private:
14508                 size_t type {0};
14509
14510         };
14511         struct Extension_t : asn::typefield<true>
14512         {
14513                 ~Extension_t()  {clear();}
14514                 size_t get_index() const {return type;}
14515                 bool is_unknown() const { return type == 1; }
14516                 void clear()
14517                 {
14518                         type = 0; ref_nested().clear();
14519                 }
14520                 template<typename V> static inline void enumerate(V& v)
14521                 {
14522
14523                 }
14524                 protected:
14525                 template<typename V> bool decode(size_t index, V& v)
14526                 {
14527                         clear();
14528                         switch(index)
14529                         {
14530                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14531                         }
14532                         return false;
14533
14534                 }
14535                 template<typename V> bool encode(size_t index, V& v) const
14536                 {
14537                         if(index != type) return false;
14538                         return false;
14539
14540                 }
14541                 private:
14542                 size_t type {0};
14543
14544         };
14545         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14546         {
14547                 size_t get_index() const {return type;}
14548                 bool is_unknown() const { return type == 1; }
14549                 void clear() {type = 0;}
14550                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14551                 template<typename V>  bool decode(V& v)
14552                 {
14553                         clear();
14554                         if(!v(ref_nested())) return false;
14555                         { type = 1; return true;}
14556                         return false;
14557
14558                 }
14559                 template<typename V> bool encode(V& v) const
14560                 {
14561                         return v(ref_nested());
14562
14563                 }
14564                 protected:
14565                 template<typename V>  bool decode(size_t index, V& v)
14566                 {
14567                         clear();
14568                         switch(index)
14569                         {
14570                         case 1: type = 1; return v(ref_nested());
14571                         ref_nested().clear();
14572                         }
14573                         return false;
14574
14575                 }
14576                 template<typename V> bool encode(size_t index, V& v) const
14577                 {
14578                         if(index != type) {return false;} return v(ref_nested());
14579
14580                 }
14581                 private:
14582                 size_t type {0};
14583
14584         };
14585
14586 };
14587 /*
14588 E-RABs-SubjectToSgNBCounterCheck-Item ::= SEQUENCE {
14589         e-RAB-ID                                                E-RAB-ID,
14590         uL-Count                                                INTEGER (0..4294967295),
14591         dL-Count                                                INTEGER (0..4294967295),
14592         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-SubjectToSgNBCounterCheck-ItemExtIEs} } OPTIONAL,
14593         ...
14594 }
14595 */
14596
14597 struct E_RABs_SubjectToSgNBCounterCheck_Item : asn::sequence<4, 0, true, 1>
14598 {
14599         static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-Item";}
14600         using parent_t = asn::sequence<4, 0, true, 1>;
14601         struct e_RAB_ID_t : E_RAB_ID
14602         {
14603                 static constexpr const char* name() {return "e_RAB_ID_t";}
14604                 using parent_t = E_RAB_ID;
14605
14606         };
14607         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
14608         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
14609         struct uL_Count_t : asn::integer<>
14610         {
14611                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14612                 static constexpr const char* name() {return "uL_Count_t";}
14613                 using parent_t = asn::integer<>;
14614
14615         };
14616
14617         uL_Count_t& ref_uL_Count() {return uL_Count;}
14618         uL_Count_t const& ref_uL_Count() const {return uL_Count;}
14619         struct dL_Count_t : asn::integer<>
14620         {
14621                 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14622                 static constexpr const char* name() {return "dL_Count_t";}
14623                 using parent_t = asn::integer<>;
14624
14625         };
14626
14627         dL_Count_t& ref_dL_Count() {return dL_Count;}
14628         dL_Count_t const& ref_dL_Count() const {return dL_Count;}
14629         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>
14630         {
14631                 static constexpr const char* name() {return "iE_Extensions_t";}
14632                 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToSgNBCounterCheck_ItemExtIEs>;
14633                 static constexpr bool optional = true;
14634
14635         };
14636         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14637         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14638         template<typename V> void decode(V& v)
14639         {
14640                 v(e_RAB_ID);
14641                 v(uL_Count);
14642                 v(dL_Count);
14643                 v(iE_Extensions);
14644
14645         };
14646         template<typename V> void encode(V& v) const
14647         {
14648                 v(e_RAB_ID);
14649                 v(uL_Count);
14650                 v(dL_Count);
14651                 v(iE_Extensions);
14652
14653         };
14654         void clear()
14655         {
14656                 e_RAB_ID.clear();
14657                 uL_Count.clear();
14658                 dL_Count.clear();
14659                 iE_Extensions.clear();
14660
14661         };
14662         private:
14663         e_RAB_ID_t      e_RAB_ID;
14664         uL_Count_t      uL_Count;
14665         dL_Count_t      dL_Count;
14666         iE_Extensions_t iE_Extensions;
14667
14668 };
14669 /*
14670 E-RABs-SubjectToSgNBCounterCheck-ItemIEs X2AP-PROTOCOL-IES ::= {
14671         { ID id-E-RABs-SubjectToSgNBCounterCheck-Item           CRITICALITY ignore      TYPE E-RABs-SubjectToSgNBCounterCheck-Item              PRESENCE mandatory},
14672         ...
14673 }
14674 */
14675
14676 struct E_RABs_SubjectToSgNBCounterCheck_ItemIEs
14677 {
14678         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14679         {
14680                 size_t get_index() const {return type;}
14681                 bool is_unknown() const { return type == 2; }
14682                 void clear() {type = 0;}
14683                 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(id_E_RABs_SubjectToSgNBCounterCheck_Item); type=1;}
14684                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14685                 template<typename V>  bool decode(V& v)
14686                 {
14687                         clear();
14688                         if(!v(ref_nested())) return false;
14689                         if(equal(id_E_RABs_SubjectToSgNBCounterCheck_Item)) { type = 1; return true; }
14690                         else { type = 2; return true;}
14691                         return false;
14692
14693                 }
14694                 template<typename V> bool encode(V& v) const
14695                 {
14696                         return v(ref_nested());
14697
14698                 }
14699                 protected:
14700                 template<typename V>  bool decode(size_t index, V& v)
14701                 {
14702                         clear();
14703                         switch(index)
14704                         {
14705                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToSgNBCounterCheck_Item);} return false;
14706                         case 2: type = 2; return v(ref_nested());
14707                         ref_nested().clear();
14708                         }
14709                         return false;
14710
14711                 }
14712                 template<typename V> bool encode(size_t index, V& v) const
14713                 {
14714                         if(index != type) {return false;} return v(ref_nested());
14715
14716                 }
14717                 private:
14718                 size_t type {0};
14719
14720         };
14721         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14722         {
14723                 size_t get_index() const {return type;}
14724                 bool is_unknown() const { return type == 2; }
14725                 void clear() {type = 0;}
14726                 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(ignore); type=1;}
14727                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14728                 template<typename V>  bool decode(V& v)
14729                 {
14730                         clear();
14731                         if(!v(ref_nested())) return false;
14732                         if(equal(ignore)) { type = 1; return true; }
14733                         else { type = 2; return true;}
14734                         return false;
14735
14736                 }
14737                 template<typename V> bool encode(V& v) const
14738                 {
14739                         return v(ref_nested());
14740
14741                 }
14742                 protected:
14743                 template<typename V>  bool decode(size_t index, V& v)
14744                 {
14745                         clear();
14746                         switch(index)
14747                         {
14748                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14749                         case 2: type = 2; return v(ref_nested());
14750                         ref_nested().clear();
14751                         }
14752                         return false;
14753
14754                 }
14755                 template<typename V> bool encode(size_t index, V& v) const
14756                 {
14757                         if(index != type) {return false;} return v(ref_nested());
14758
14759                 }
14760                 private:
14761                 size_t type {0};
14762
14763         };
14764         struct Value_t : asn::typefield<true>
14765         {
14766                 ~Value_t()      {clear();}
14767                 size_t get_index() const {return type;}
14768                 E_RABs_SubjectToSgNBCounterCheck_Item& select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { return set<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
14769                 E_RABs_SubjectToSgNBCounterCheck_Item const* get_id_E_RABs_SubjectToSgNBCounterCheck_Item() const { return get<E_RABs_SubjectToSgNBCounterCheck_Item>(1); }
14770                 bool is_unknown() const { return type == 2; }
14771                 void clear()
14772                 {
14773                         switch(type)
14774                         {
14775                         case 1: var.destroy<E_RABs_SubjectToSgNBCounterCheck_Item>(); break;
14776                         }
14777                         type = 0; ref_nested().clear();
14778                 }
14779                 template<typename V> static inline void enumerate(V& v)
14780                 {
14781                         v.template operator()<E_RABs_SubjectToSgNBCounterCheck_Item>(1);
14782
14783                 }
14784                 protected:
14785                 template<typename V> bool decode(size_t index, V& v)
14786                 {
14787                         clear();
14788                         switch(index)
14789                         {
14790                         case 1: v(select_id_E_RABs_SubjectToSgNBCounterCheck_Item()); return true;
14791                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14792                         }
14793                         return false;
14794
14795                 }
14796                 template<typename V> bool encode(size_t index, V& v) const
14797                 {
14798                         if(index != type) return false;
14799                         switch(type)
14800                         {
14801                         case 1: v(var.as<E_RABs_SubjectToSgNBCounterCheck_Item>()); return true;
14802                         }
14803                         return false;
14804
14805                 }
14806                 private:
14807                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14808                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14809                 union union_type
14810                 {
14811                         char dummy1[sizeof(E_RABs_SubjectToSgNBCounterCheck_Item)];
14812
14813                 };
14814                 asn::variant<sizeof(union_type)> var;
14815                 size_t type {0};
14816
14817         };
14818         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14819         {
14820                 size_t get_index() const {return type;}
14821                 bool is_unknown() const { return type == 2; }
14822                 void clear() {type = 0;}
14823                 void select_id_E_RABs_SubjectToSgNBCounterCheck_Item() { set(mandatory); type=1;}
14824                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14825                 template<typename V>  bool decode(V& v)
14826                 {
14827                         clear();
14828                         if(!v(ref_nested())) return false;
14829                         if(equal(mandatory)) { type = 1; return true; }
14830                         else { type = 2; return true;}
14831                         return false;
14832
14833                 }
14834                 template<typename V> bool encode(V& v) const
14835                 {
14836                         return v(ref_nested());
14837
14838                 }
14839                 protected:
14840                 template<typename V>  bool decode(size_t index, V& v)
14841                 {
14842                         clear();
14843                         switch(index)
14844                         {
14845                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14846                         case 2: type = 2; return v(ref_nested());
14847                         ref_nested().clear();
14848                         }
14849                         return false;
14850
14851                 }
14852                 template<typename V> bool encode(size_t index, V& v) const
14853                 {
14854                         if(index != type) {return false;} return v(ref_nested());
14855
14856                 }
14857                 private:
14858                 size_t type {0};
14859
14860         };
14861
14862 };
14863 /*
14864 E-RABs-SubjectToSgNBCounterCheck-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToSgNBCounterCheck-ItemIEs} }
14865 */
14866
14867 struct E_RABs_SubjectToSgNBCounterCheck_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>
14868 {
14869         static constexpr const char* name() {return "E_RABs_SubjectToSgNBCounterCheck_List_elm";}
14870         using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToSgNBCounterCheck_ItemIEs>;
14871
14872 };
14873 struct E_RABs_SubjectToSgNBCounterCheck_List : asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>
14874 {
14875         static constexpr const char* name() {return "E-RABs-SubjectToSgNBCounterCheck-List";}
14876         using parent_t = asn::sequenceof<E_RABs_SubjectToSgNBCounterCheck_List_elm>;
14877         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
14878
14879 };
14880 /*
14881 E-RABs-SubjectToStatusTransfer-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14882         { ID id-ReceiveStatusOfULPDCPSDUsExtended                       CRITICALITY ignore      EXTENSION ReceiveStatusOfULPDCPSDUsExtended                     PRESENCE optional}|
14883         { ID id-ULCOUNTValueExtended                                            CRITICALITY ignore      EXTENSION COUNTValueExtended                                                            PRESENCE optional}|
14884         { ID id-DLCOUNTValueExtended                                            CRITICALITY ignore      EXTENSION COUNTValueExtended                                                            PRESENCE optional}|
14885         { ID id-ReceiveStatusOfULPDCPSDUsPDCP-SNlength18        CRITICALITY ignore      EXTENSION ReceiveStatusOfULPDCPSDUsPDCP-SNlength18      PRESENCE optional}|
14886         { ID id-ULCOUNTValuePDCP-SNlength18                                     CRITICALITY ignore      EXTENSION COUNTvaluePDCP-SNlength18                                             PRESENCE optional}|
14887         { ID id-DLCOUNTValuePDCP-SNlength18                                     CRITICALITY ignore      EXTENSION COUNTvaluePDCP-SNlength18                                             PRESENCE optional},
14888         ...
14889 }
14890 */
14891
14892 struct E_RABs_SubjectToStatusTransfer_ItemExtIEs
14893 {
14894         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14895         {
14896                 size_t get_index() const {return type;}
14897                 bool is_unknown() const { return type == 7; }
14898                 void clear() {type = 0;}
14899                 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(id_ReceiveStatusOfULPDCPSDUsExtended); type=1;}
14900                 void select_id_ULCOUNTValueExtended() { set(id_ULCOUNTValueExtended); type=2;}
14901                 void select_id_DLCOUNTValueExtended() { set(id_DLCOUNTValueExtended); type=3;}
14902                 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18); type=4;}
14903                 void select_id_ULCOUNTValuePDCP_SNlength18() { set(id_ULCOUNTValuePDCP_SNlength18); type=5;}
14904                 void select_id_DLCOUNTValuePDCP_SNlength18() { set(id_DLCOUNTValuePDCP_SNlength18); type=6;}
14905                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14906                 template<typename V>  bool decode(V& v)
14907                 {
14908                         clear();
14909                         if(!v(ref_nested())) return false;
14910                         if(equal(id_ReceiveStatusOfULPDCPSDUsExtended)) { type = 1; return true; }
14911                         else if(equal(id_ULCOUNTValueExtended)) { type = 2; return true; }
14912                         else if(equal(id_DLCOUNTValueExtended)) { type = 3; return true; }
14913                         else if(equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)) { type = 4; return true; }
14914                         else if(equal(id_ULCOUNTValuePDCP_SNlength18)) { type = 5; return true; }
14915                         else if(equal(id_DLCOUNTValuePDCP_SNlength18)) { type = 6; return true; }
14916                         else { type = 7; return true;}
14917                         return false;
14918
14919                 }
14920                 template<typename V> bool encode(V& v) const
14921                 {
14922                         return v(ref_nested());
14923
14924                 }
14925                 protected:
14926                 template<typename V>  bool decode(size_t index, V& v)
14927                 {
14928                         clear();
14929                         switch(index)
14930                         {
14931                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ReceiveStatusOfULPDCPSDUsExtended);} return false;
14932                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ULCOUNTValueExtended);} return false;
14933                         case 3: type = 3; if(v(ref_nested())) { return equal(id_DLCOUNTValueExtended);} return false;
14934                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18);} return false;
14935                         case 5: type = 5; if(v(ref_nested())) { return equal(id_ULCOUNTValuePDCP_SNlength18);} return false;
14936                         case 6: type = 6; if(v(ref_nested())) { return equal(id_DLCOUNTValuePDCP_SNlength18);} return false;
14937                         case 7: type = 7; return v(ref_nested());
14938                         ref_nested().clear();
14939                         }
14940                         return false;
14941
14942                 }
14943                 template<typename V> bool encode(size_t index, V& v) const
14944                 {
14945                         if(index != type) {return false;} return v(ref_nested());
14946
14947                 }
14948                 private:
14949                 size_t type {0};
14950
14951         };
14952         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14953         {
14954                 size_t get_index() const {return type;}
14955                 bool is_unknown() const { return type == 7; }
14956                 void clear() {type = 0;}
14957                 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(ignore); type=1;}
14958                 void select_id_ULCOUNTValueExtended() { set(ignore); type=2;}
14959                 void select_id_DLCOUNTValueExtended() { set(ignore); type=3;}
14960                 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(ignore); type=4;}
14961                 void select_id_ULCOUNTValuePDCP_SNlength18() { set(ignore); type=5;}
14962                 void select_id_DLCOUNTValuePDCP_SNlength18() { set(ignore); type=6;}
14963                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14964                 template<typename V>  bool decode(V& v)
14965                 {
14966                         clear();
14967                         if(!v(ref_nested())) return false;
14968                         if(equal(ignore)) { type = 1; return true; }
14969                         else if(equal(ignore)) { type = 2; return true; }
14970                         else if(equal(ignore)) { type = 3; return true; }
14971                         else if(equal(ignore)) { type = 4; return true; }
14972                         else if(equal(ignore)) { type = 5; return true; }
14973                         else if(equal(ignore)) { type = 6; return true; }
14974                         else { type = 7; return true;}
14975                         return false;
14976
14977                 }
14978                 template<typename V> bool encode(V& v) const
14979                 {
14980                         return v(ref_nested());
14981
14982                 }
14983                 protected:
14984                 template<typename V>  bool decode(size_t index, V& v)
14985                 {
14986                         clear();
14987                         switch(index)
14988                         {
14989                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14990                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
14991                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
14992                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
14993                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
14994                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
14995                         case 7: type = 7; return v(ref_nested());
14996                         ref_nested().clear();
14997                         }
14998                         return false;
14999
15000                 }
15001                 template<typename V> bool encode(size_t index, V& v) const
15002                 {
15003                         if(index != type) {return false;} return v(ref_nested());
15004
15005                 }
15006                 private:
15007                 size_t type {0};
15008
15009         };
15010         struct Extension_t : asn::typefield<true>
15011         {
15012                 ~Extension_t()  {clear();}
15013                 size_t get_index() const {return type;}
15014                 ReceiveStatusOfULPDCPSDUsExtended& select_id_ReceiveStatusOfULPDCPSDUsExtended() { return set<ReceiveStatusOfULPDCPSDUsExtended>(1); }
15015                 ReceiveStatusOfULPDCPSDUsExtended const* get_id_ReceiveStatusOfULPDCPSDUsExtended() const { return get<ReceiveStatusOfULPDCPSDUsExtended>(1); }
15016                 COUNTValueExtended& select_id_ULCOUNTValueExtended() { return set<COUNTValueExtended>(2); }
15017                 COUNTValueExtended const* get_id_ULCOUNTValueExtended() const { return get<COUNTValueExtended>(2); }
15018                 COUNTValueExtended& select_id_DLCOUNTValueExtended() { return set<COUNTValueExtended>(3); }
15019                 COUNTValueExtended const* get_id_DLCOUNTValueExtended() const { return get<COUNTValueExtended>(3); }
15020                 ReceiveStatusOfULPDCPSDUsPDCP_SNlength18& select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { return set<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
15021                 ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 const* get_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() const { return get<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4); }
15022                 COUNTvaluePDCP_SNlength18& select_id_ULCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(5); }
15023                 COUNTvaluePDCP_SNlength18 const* get_id_ULCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(5); }
15024                 COUNTvaluePDCP_SNlength18& select_id_DLCOUNTValuePDCP_SNlength18() { return set<COUNTvaluePDCP_SNlength18>(6); }
15025                 COUNTvaluePDCP_SNlength18 const* get_id_DLCOUNTValuePDCP_SNlength18() const { return get<COUNTvaluePDCP_SNlength18>(6); }
15026                 bool is_unknown() const { return type == 7; }
15027                 void clear()
15028                 {
15029                         switch(type)
15030                         {
15031                         case 1: var.destroy<ReceiveStatusOfULPDCPSDUsExtended>(); break;
15032                         case 2: var.destroy<COUNTValueExtended>(); break;
15033                         case 3: var.destroy<COUNTValueExtended>(); break;
15034                         case 4: var.destroy<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(); break;
15035                         case 5: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
15036                         case 6: var.destroy<COUNTvaluePDCP_SNlength18>(); break;
15037                         }
15038                         type = 0; ref_nested().clear();
15039                 }
15040                 template<typename V> static inline void enumerate(V& v)
15041                 {
15042                         v.template operator()<ReceiveStatusOfULPDCPSDUsExtended>(1);
15043                         v.template operator()<COUNTValueExtended>(2);
15044                         v.template operator()<COUNTValueExtended>(3);
15045                         v.template operator()<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>(4);
15046                         v.template operator()<COUNTvaluePDCP_SNlength18>(5);
15047                         v.template operator()<COUNTvaluePDCP_SNlength18>(6);
15048
15049                 }
15050                 protected:
15051                 template<typename V> bool decode(size_t index, V& v)
15052                 {
15053                         clear();
15054                         switch(index)
15055                         {
15056                         case 1: v(select_id_ReceiveStatusOfULPDCPSDUsExtended()); return true;
15057                         case 2: v(select_id_ULCOUNTValueExtended()); return true;
15058                         case 3: v(select_id_DLCOUNTValueExtended()); return true;
15059                         case 4: v(select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18()); return true;
15060                         case 5: v(select_id_ULCOUNTValuePDCP_SNlength18()); return true;
15061                         case 6: v(select_id_DLCOUNTValuePDCP_SNlength18()); return true;
15062                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
15063                         }
15064                         return false;
15065
15066                 }
15067                 template<typename V> bool encode(size_t index, V& v) const
15068                 {
15069                         if(index != type) return false;
15070                         switch(type)
15071                         {
15072                         case 1: v(var.as<ReceiveStatusOfULPDCPSDUsExtended>()); return true;
15073                         case 2: v(var.as<COUNTValueExtended>()); return true;
15074                         case 3: v(var.as<COUNTValueExtended>()); return true;
15075                         case 4: v(var.as<ReceiveStatusOfULPDCPSDUsPDCP_SNlength18>()); return true;
15076                         case 5: v(var.as<COUNTvaluePDCP_SNlength18>()); return true;
15077                         case 6: v(var.as<COUNTvaluePDCP_SNlength18>()); return true;
15078                         }
15079                         return false;
15080
15081                 }
15082                 private:
15083                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15084                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15085                 union union_type
15086                 {
15087                         char dummy1[sizeof(COUNTValueExtended)];
15088                         char dummy2[sizeof(COUNTvaluePDCP_SNlength18)];
15089                         char dummy3[sizeof(ReceiveStatusOfULPDCPSDUsExtended)];
15090                         char dummy4[sizeof(ReceiveStatusOfULPDCPSDUsPDCP_SNlength18)];
15091
15092                 };
15093                 asn::variant<sizeof(union_type)> var;
15094                 size_t type {0};
15095
15096         };
15097         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15098         {
15099                 size_t get_index() const {return type;}
15100                 bool is_unknown() const { return type == 7; }
15101                 void clear() {type = 0;}
15102                 void select_id_ReceiveStatusOfULPDCPSDUsExtended() { set(optional); type=1;}
15103                 void select_id_ULCOUNTValueExtended() { set(optional); type=2;}
15104                 void select_id_DLCOUNTValueExtended() { set(optional); type=3;}
15105                 void select_id_ReceiveStatusOfULPDCPSDUsPDCP_SNlength18() { set(optional); type=4;}
15106                 void select_id_ULCOUNTValuePDCP_SNlength18() { set(optional); type=5;}
15107                 void select_id_DLCOUNTValuePDCP_SNlength18() { set(optional); type=6;}
15108                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15109                 template<typename V>  bool decode(V& v)
15110                 {
15111                         clear();
15112                         if(!v(ref_nested())) return false;
15113                         if(equal(optional)) { type = 1; return true; }
15114                         else if(equal(optional)) { type = 2; return true; }
15115                         else if(equal(optional)) { type = 3; return true; }
15116                         else if(equal(optional)) { type = 4; return true; }
15117                         else if(equal(optional)) { type = 5; return true; }
15118                         else if(equal(optional)) { type = 6; return true; }
15119                         else { type = 7; return true;}
15120                         return false;
15121
15122                 }
15123                 template<typename V> bool encode(V& v) const
15124                 {
15125                         return v(ref_nested());
15126
15127                 }
15128                 protected:
15129                 template<typename V>  bool decode(size_t index, V& v)
15130                 {
15131                         clear();
15132                         switch(index)
15133                         {
15134                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15135                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15136                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
15137                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
15138                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
15139                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
15140                         case 7: type = 7; return v(ref_nested());
15141                         ref_nested().clear();
15142                         }
15143                         return false;
15144
15145                 }
15146                 template<typename V> bool encode(size_t index, V& v) const
15147                 {
15148                         if(index != type) {return false;} return v(ref_nested());
15149
15150                 }
15151                 private:
15152                 size_t type {0};
15153
15154         };
15155
15156 };
15157 /*
15158 E-RABs-SubjectToStatusTransfer-Item ::= SEQUENCE {
15159         e-RAB-ID                                                                E-RAB-ID,
15160
15161         receiveStatusofULPDCPSDUs                               ReceiveStatusofULPDCPSDUs                       OPTIONAL,
15162         uL-COUNTvalue                                   COUNTvalue,
15163         dL-COUNTvalue                                   COUNTvalue,
15164         iE-Extensions                                                   ProtocolExtensionContainer { {E-RABs-SubjectToStatusTransfer-ItemExtIEs} } OPTIONAL,
15165         ...
15166 }
15167 */
15168
15169 struct E_RABs_SubjectToStatusTransfer_Item : asn::sequence<5, 0, true, 2>
15170 {
15171         static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-Item";}
15172         using parent_t = asn::sequence<5, 0, true, 2>;
15173         struct e_RAB_ID_t : E_RAB_ID
15174         {
15175                 static constexpr const char* name() {return "e_RAB_ID_t";}
15176                 using parent_t = E_RAB_ID;
15177
15178         };
15179         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15180         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15181         struct receiveStatusofULPDCPSDUs_t : ReceiveStatusofULPDCPSDUs
15182         {
15183                 static constexpr const char* name() {return "receiveStatusofULPDCPSDUs_t";}
15184                 using parent_t = ReceiveStatusofULPDCPSDUs;
15185                 static constexpr bool optional = true;
15186
15187         };
15188         receiveStatusofULPDCPSDUs_t& set_receiveStatusofULPDCPSDUs() { receiveStatusofULPDCPSDUs.setpresent(true); return receiveStatusofULPDCPSDUs;}
15189         receiveStatusofULPDCPSDUs_t const* get_receiveStatusofULPDCPSDUs() const {return receiveStatusofULPDCPSDUs.is_valid() ? &receiveStatusofULPDCPSDUs : nullptr;}
15190         struct uL_COUNTvalue_t : COUNTvalue
15191         {
15192                 static constexpr const char* name() {return "uL_COUNTvalue_t";}
15193                 using parent_t = COUNTvalue;
15194
15195         };
15196         uL_COUNTvalue_t& ref_uL_COUNTvalue() {return uL_COUNTvalue;}
15197         uL_COUNTvalue_t const& ref_uL_COUNTvalue() const {return uL_COUNTvalue;}
15198         struct dL_COUNTvalue_t : COUNTvalue
15199         {
15200                 static constexpr const char* name() {return "dL_COUNTvalue_t";}
15201                 using parent_t = COUNTvalue;
15202
15203         };
15204         dL_COUNTvalue_t& ref_dL_COUNTvalue() {return dL_COUNTvalue;}
15205         dL_COUNTvalue_t const& ref_dL_COUNTvalue() const {return dL_COUNTvalue;}
15206         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>
15207         {
15208                 static constexpr const char* name() {return "iE_Extensions_t";}
15209                 using parent_t = ProtocolExtensionContainer<E_RABs_SubjectToStatusTransfer_ItemExtIEs>;
15210                 static constexpr bool optional = true;
15211
15212         };
15213         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15214         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15215         template<typename V> void decode(V& v)
15216         {
15217                 v(e_RAB_ID);
15218                 v(receiveStatusofULPDCPSDUs);
15219                 v(uL_COUNTvalue);
15220                 v(dL_COUNTvalue);
15221                 v(iE_Extensions);
15222
15223         };
15224         template<typename V> void encode(V& v) const
15225         {
15226                 v(e_RAB_ID);
15227                 v(receiveStatusofULPDCPSDUs);
15228                 v(uL_COUNTvalue);
15229                 v(dL_COUNTvalue);
15230                 v(iE_Extensions);
15231
15232         };
15233         void clear()
15234         {
15235                 e_RAB_ID.clear();
15236                 receiveStatusofULPDCPSDUs.clear();
15237                 uL_COUNTvalue.clear();
15238                 dL_COUNTvalue.clear();
15239                 iE_Extensions.clear();
15240
15241         };
15242         private:
15243         e_RAB_ID_t      e_RAB_ID;
15244         receiveStatusofULPDCPSDUs_t     receiveStatusofULPDCPSDUs;
15245         uL_COUNTvalue_t uL_COUNTvalue;
15246         dL_COUNTvalue_t dL_COUNTvalue;
15247         iE_Extensions_t iE_Extensions;
15248
15249 };
15250 /*
15251 E-RABs-SubjectToStatusTransfer-ItemIEs X2AP-PROTOCOL-IES ::= {
15252         { ID id-E-RABs-SubjectToStatusTransfer-Item     CRITICALITY ignore      TYPE E-RABs-SubjectToStatusTransfer-Item        PRESENCE mandatory      }
15253 }
15254 */
15255
15256 struct E_RABs_SubjectToStatusTransfer_ItemIEs
15257 {
15258         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
15259         {
15260                 size_t get_index() const {return type;}
15261                 void clear() {type = 0;}
15262                 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(id_E_RABs_SubjectToStatusTransfer_Item); type=1;}
15263                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
15264                 template<typename V>  bool decode(V& v)
15265                 {
15266                         clear();
15267                         if(!v(ref_nested())) return false;
15268                         if(equal(id_E_RABs_SubjectToStatusTransfer_Item)) { type = 1; return true; }
15269                         return false;
15270
15271                 }
15272                 template<typename V> bool encode(V& v) const
15273                 {
15274                         return v(ref_nested());
15275
15276                 }
15277                 protected:
15278                 template<typename V>  bool decode(size_t index, V& v)
15279                 {
15280                         clear();
15281                         switch(index)
15282                         {
15283                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToStatusTransfer_Item);} return false;
15284                         ref_nested().clear();
15285                         }
15286                         return false;
15287
15288                 }
15289                 template<typename V> bool encode(size_t index, V& v) const
15290                 {
15291                         if(index != type) {return false;} return v(ref_nested());
15292
15293                 }
15294                 private:
15295                 size_t type {0};
15296
15297         };
15298         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
15299         {
15300                 size_t get_index() const {return type;}
15301                 void clear() {type = 0;}
15302                 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(ignore); type=1;}
15303                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
15304                 template<typename V>  bool decode(V& v)
15305                 {
15306                         clear();
15307                         if(!v(ref_nested())) return false;
15308                         if(equal(ignore)) { type = 1; return true; }
15309                         return false;
15310
15311                 }
15312                 template<typename V> bool encode(V& v) const
15313                 {
15314                         return v(ref_nested());
15315
15316                 }
15317                 protected:
15318                 template<typename V>  bool decode(size_t index, V& v)
15319                 {
15320                         clear();
15321                         switch(index)
15322                         {
15323                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
15324                         ref_nested().clear();
15325                         }
15326                         return false;
15327
15328                 }
15329                 template<typename V> bool encode(size_t index, V& v) const
15330                 {
15331                         if(index != type) {return false;} return v(ref_nested());
15332
15333                 }
15334                 private:
15335                 size_t type {0};
15336
15337         };
15338         struct Value_t : asn::typefield<false>
15339         {
15340                 ~Value_t()      {clear();}
15341                 size_t get_index() const {return type;}
15342                 E_RABs_SubjectToStatusTransfer_Item& select_id_E_RABs_SubjectToStatusTransfer_Item() { return set<E_RABs_SubjectToStatusTransfer_Item>(1); }
15343                 E_RABs_SubjectToStatusTransfer_Item const* get_id_E_RABs_SubjectToStatusTransfer_Item() const { return get<E_RABs_SubjectToStatusTransfer_Item>(1); }
15344                 void clear()
15345                 {
15346                         switch(type)
15347                         {
15348                         case 1: var.destroy<E_RABs_SubjectToStatusTransfer_Item>(); break;
15349                         }
15350                         type = 0; ref_nested().clear();
15351                 }
15352                 template<typename V> static inline void enumerate(V& v)
15353                 {
15354                         v.template operator()<E_RABs_SubjectToStatusTransfer_Item>(1);
15355
15356                 }
15357                 protected:
15358                 template<typename V> bool decode(size_t index, V& v)
15359                 {
15360                         clear();
15361                         switch(index)
15362                         {
15363                         case 1: v(select_id_E_RABs_SubjectToStatusTransfer_Item()); return true;
15364                         }
15365                         return false;
15366
15367                 }
15368                 template<typename V> bool encode(size_t index, V& v) const
15369                 {
15370                         if(index != type) return false;
15371                         switch(type)
15372                         {
15373                         case 1: v(var.as<E_RABs_SubjectToStatusTransfer_Item>()); return true;
15374                         }
15375                         return false;
15376
15377                 }
15378                 private:
15379                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15380                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15381                 union union_type
15382                 {
15383                         char dummy1[sizeof(E_RABs_SubjectToStatusTransfer_Item)];
15384
15385                 };
15386                 asn::variant<sizeof(union_type)> var;
15387                 size_t type {0};
15388
15389         };
15390         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
15391         {
15392                 size_t get_index() const {return type;}
15393                 void clear() {type = 0;}
15394                 void select_id_E_RABs_SubjectToStatusTransfer_Item() { set(mandatory); type=1;}
15395                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
15396                 template<typename V>  bool decode(V& v)
15397                 {
15398                         clear();
15399                         if(!v(ref_nested())) return false;
15400                         if(equal(mandatory)) { type = 1; return true; }
15401                         return false;
15402
15403                 }
15404                 template<typename V> bool encode(V& v) const
15405                 {
15406                         return v(ref_nested());
15407
15408                 }
15409                 protected:
15410                 template<typename V>  bool decode(size_t index, V& v)
15411                 {
15412                         clear();
15413                         switch(index)
15414                         {
15415                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
15416                         ref_nested().clear();
15417                         }
15418                         return false;
15419
15420                 }
15421                 template<typename V> bool encode(size_t index, V& v) const
15422                 {
15423                         if(index != type) {return false;} return v(ref_nested());
15424
15425                 }
15426                 private:
15427                 size_t type {0};
15428
15429         };
15430
15431 };
15432 /*
15433 E-RABs-SubjectToStatusTransfer-List     ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-SubjectToStatusTransfer-ItemIEs} }
15434 */
15435
15436 struct E_RABs_SubjectToStatusTransfer_List_elm : ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>
15437 {
15438         static constexpr const char* name() {return "E_RABs_SubjectToStatusTransfer_List_elm";}
15439         using parent_t = ProtocolIE_Single_Container<E_RABs_SubjectToStatusTransfer_ItemIEs>;
15440
15441 };
15442 struct E_RABs_SubjectToStatusTransfer_List : asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>
15443 {
15444         static constexpr const char* name() {return "E-RABs-SubjectToStatusTransfer-List";}
15445         using parent_t = asn::sequenceof<E_RABs_SubjectToStatusTransfer_List_elm>;
15446         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
15447
15448 };
15449 /*
15450 E-RABs-ToBeAdded-Item-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15451         { ID id-Correlation-ID                          CRITICALITY ignore      EXTENSION Correlation-ID                PRESENCE optional}|
15452         { ID id-SIPTO-Correlation-ID            CRITICALITY ignore      EXTENSION Correlation-ID                PRESENCE optional},
15453         ...
15454 }
15455 */
15456
15457 struct E_RABs_ToBeAdded_Item_SCG_BearerExtIEs
15458 {
15459         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15460         {
15461                 size_t get_index() const {return type;}
15462                 bool is_unknown() const { return type == 3; }
15463                 void clear() {type = 0;}
15464                 void select_id_Correlation_ID() { set(id_Correlation_ID); type=1;}
15465                 void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); type=2;}
15466                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15467                 template<typename V>  bool decode(V& v)
15468                 {
15469                         clear();
15470                         if(!v(ref_nested())) return false;
15471                         if(equal(id_Correlation_ID)) { type = 1; return true; }
15472                         else if(equal(id_SIPTO_Correlation_ID)) { type = 2; return true; }
15473                         else { type = 3; return true;}
15474                         return false;
15475
15476                 }
15477                 template<typename V> bool encode(V& v) const
15478                 {
15479                         return v(ref_nested());
15480
15481                 }
15482                 protected:
15483                 template<typename V>  bool decode(size_t index, V& v)
15484                 {
15485                         clear();
15486                         switch(index)
15487                         {
15488                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Correlation_ID);} return false;
15489                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} return false;
15490                         case 3: type = 3; return v(ref_nested());
15491                         ref_nested().clear();
15492                         }
15493                         return false;
15494
15495                 }
15496                 template<typename V> bool encode(size_t index, V& v) const
15497                 {
15498                         if(index != type) {return false;} return v(ref_nested());
15499
15500                 }
15501                 private:
15502                 size_t type {0};
15503
15504         };
15505         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15506         {
15507                 size_t get_index() const {return type;}
15508                 bool is_unknown() const { return type == 3; }
15509                 void clear() {type = 0;}
15510                 void select_id_Correlation_ID() { set(ignore); type=1;}
15511                 void select_id_SIPTO_Correlation_ID() { set(ignore); type=2;}
15512                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15513                 template<typename V>  bool decode(V& v)
15514                 {
15515                         clear();
15516                         if(!v(ref_nested())) return false;
15517                         if(equal(ignore)) { type = 1; return true; }
15518                         else if(equal(ignore)) { type = 2; return true; }
15519                         else { type = 3; return true;}
15520                         return false;
15521
15522                 }
15523                 template<typename V> bool encode(V& v) const
15524                 {
15525                         return v(ref_nested());
15526
15527                 }
15528                 protected:
15529                 template<typename V>  bool decode(size_t index, V& v)
15530                 {
15531                         clear();
15532                         switch(index)
15533                         {
15534                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
15535                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
15536                         case 3: type = 3; return v(ref_nested());
15537                         ref_nested().clear();
15538                         }
15539                         return false;
15540
15541                 }
15542                 template<typename V> bool encode(size_t index, V& v) const
15543                 {
15544                         if(index != type) {return false;} return v(ref_nested());
15545
15546                 }
15547                 private:
15548                 size_t type {0};
15549
15550         };
15551         struct Extension_t : asn::typefield<true>
15552         {
15553                 ~Extension_t()  {clear();}
15554                 size_t get_index() const {return type;}
15555                 Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
15556                 Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
15557                 Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
15558                 Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
15559                 bool is_unknown() const { return type == 3; }
15560                 void clear()
15561                 {
15562                         switch(type)
15563                         {
15564                         case 1: var.destroy<Correlation_ID>(); break;
15565                         case 2: var.destroy<Correlation_ID>(); break;
15566                         }
15567                         type = 0; ref_nested().clear();
15568                 }
15569                 template<typename V> static inline void enumerate(V& v)
15570                 {
15571                         v.template operator()<Correlation_ID>(1);
15572                         v.template operator()<Correlation_ID>(2);
15573
15574                 }
15575                 protected:
15576                 template<typename V> bool decode(size_t index, V& v)
15577                 {
15578                         clear();
15579                         switch(index)
15580                         {
15581                         case 1: v(select_id_Correlation_ID()); return true;
15582                         case 2: v(select_id_SIPTO_Correlation_ID()); return true;
15583                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
15584                         }
15585                         return false;
15586
15587                 }
15588                 template<typename V> bool encode(size_t index, V& v) const
15589                 {
15590                         if(index != type) return false;
15591                         switch(type)
15592                         {
15593                         case 1: v(var.as<Correlation_ID>()); return true;
15594                         case 2: v(var.as<Correlation_ID>()); return true;
15595                         }
15596                         return false;
15597
15598                 }
15599                 private:
15600                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15601                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15602                 union union_type
15603                 {
15604                         char dummy1[sizeof(Correlation_ID)];
15605
15606                 };
15607                 asn::variant<sizeof(union_type)> var;
15608                 size_t type {0};
15609
15610         };
15611         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15612         {
15613                 size_t get_index() const {return type;}
15614                 bool is_unknown() const { return type == 3; }
15615                 void clear() {type = 0;}
15616                 void select_id_Correlation_ID() { set(optional); type=1;}
15617                 void select_id_SIPTO_Correlation_ID() { set(optional); type=2;}
15618                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15619                 template<typename V>  bool decode(V& v)
15620                 {
15621                         clear();
15622                         if(!v(ref_nested())) return false;
15623                         if(equal(optional)) { type = 1; return true; }
15624                         else if(equal(optional)) { type = 2; return true; }
15625                         else { type = 3; return true;}
15626                         return false;
15627
15628                 }
15629                 template<typename V> bool encode(V& v) const
15630                 {
15631                         return v(ref_nested());
15632
15633                 }
15634                 protected:
15635                 template<typename V>  bool decode(size_t index, V& v)
15636                 {
15637                         clear();
15638                         switch(index)
15639                         {
15640                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15641                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15642                         case 3: type = 3; return v(ref_nested());
15643                         ref_nested().clear();
15644                         }
15645                         return false;
15646
15647                 }
15648                 template<typename V> bool encode(size_t index, V& v) const
15649                 {
15650                         if(index != type) {return false;} return v(ref_nested());
15651
15652                 }
15653                 private:
15654                 size_t type {0};
15655
15656         };
15657
15658 };
15659 /*
15660 E-RABs-ToBeAdded-Item-SCG-Bearer ::= SEQUENCE {
15661         e-RAB-ID                                                E-RAB-ID,
15662         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
15663         dL-Forwarding                                   DL-Forwarding                                                                                                                                   OPTIONAL,
15664         s1-UL-GTPtunnelEndpoint                 GTPtunnelEndpoint,
15665         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-SCG-BearerExtIEs} } OPTIONAL,
15666         ...
15667 }
15668 */
15669
15670 struct E_RABs_ToBeAdded_Item_SCG_Bearer : asn::sequence<5, 0, true, 2>
15671 {
15672         static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-SCG-Bearer";}
15673         using parent_t = asn::sequence<5, 0, true, 2>;
15674         struct e_RAB_ID_t : E_RAB_ID
15675         {
15676                 static constexpr const char* name() {return "e_RAB_ID_t";}
15677                 using parent_t = E_RAB_ID;
15678
15679         };
15680         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15681         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15682         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
15683         {
15684                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
15685                 using parent_t = E_RAB_Level_QoS_Parameters;
15686
15687         };
15688         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
15689         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
15690         struct dL_Forwarding_t : DL_Forwarding
15691         {
15692                 static constexpr const char* name() {return "dL_Forwarding_t";}
15693                 using parent_t = DL_Forwarding;
15694                 static constexpr bool optional = true;
15695
15696         };
15697         dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
15698         dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
15699         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
15700         {
15701                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
15702                 using parent_t = GTPtunnelEndpoint;
15703
15704         };
15705         s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
15706         s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
15707         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>
15708         {
15709                 static constexpr const char* name() {return "iE_Extensions_t";}
15710                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_SCG_BearerExtIEs>;
15711                 static constexpr bool optional = true;
15712
15713         };
15714         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15715         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15716         template<typename V> void decode(V& v)
15717         {
15718                 v(e_RAB_ID);
15719                 v(e_RAB_Level_QoS_Parameters);
15720                 v(dL_Forwarding);
15721                 v(s1_UL_GTPtunnelEndpoint);
15722                 v(iE_Extensions);
15723
15724         };
15725         template<typename V> void encode(V& v) const
15726         {
15727                 v(e_RAB_ID);
15728                 v(e_RAB_Level_QoS_Parameters);
15729                 v(dL_Forwarding);
15730                 v(s1_UL_GTPtunnelEndpoint);
15731                 v(iE_Extensions);
15732
15733         };
15734         void clear()
15735         {
15736                 e_RAB_ID.clear();
15737                 e_RAB_Level_QoS_Parameters.clear();
15738                 dL_Forwarding.clear();
15739                 s1_UL_GTPtunnelEndpoint.clear();
15740                 iE_Extensions.clear();
15741
15742         };
15743         private:
15744         e_RAB_ID_t      e_RAB_ID;
15745         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
15746         dL_Forwarding_t dL_Forwarding;
15747         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
15748         iE_Extensions_t iE_Extensions;
15749
15750 };
15751 /*
15752 E-RABs-ToBeAdded-Item-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15753         ...
15754 }
15755 */
15756
15757 struct E_RABs_ToBeAdded_Item_Split_BearerExtIEs
15758 {
15759         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15760         {
15761                 size_t get_index() const {return type;}
15762                 bool is_unknown() const { return type == 1; }
15763                 void clear() {type = 0;}
15764                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15765                 template<typename V>  bool decode(V& v)
15766                 {
15767                         clear();
15768                         if(!v(ref_nested())) return false;
15769                         { type = 1; return true;}
15770                         return false;
15771
15772                 }
15773                 template<typename V> bool encode(V& v) const
15774                 {
15775                         return v(ref_nested());
15776
15777                 }
15778                 protected:
15779                 template<typename V>  bool decode(size_t index, V& v)
15780                 {
15781                         clear();
15782                         switch(index)
15783                         {
15784                         case 1: type = 1; return v(ref_nested());
15785                         ref_nested().clear();
15786                         }
15787                         return false;
15788
15789                 }
15790                 template<typename V> bool encode(size_t index, V& v) const
15791                 {
15792                         if(index != type) {return false;} return v(ref_nested());
15793
15794                 }
15795                 private:
15796                 size_t type {0};
15797
15798         };
15799         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15800         {
15801                 size_t get_index() const {return type;}
15802                 bool is_unknown() const { return type == 1; }
15803                 void clear() {type = 0;}
15804                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15805                 template<typename V>  bool decode(V& v)
15806                 {
15807                         clear();
15808                         if(!v(ref_nested())) return false;
15809                         { type = 1; return true;}
15810                         return false;
15811
15812                 }
15813                 template<typename V> bool encode(V& v) const
15814                 {
15815                         return v(ref_nested());
15816
15817                 }
15818                 protected:
15819                 template<typename V>  bool decode(size_t index, V& v)
15820                 {
15821                         clear();
15822                         switch(index)
15823                         {
15824                         case 1: type = 1; return v(ref_nested());
15825                         ref_nested().clear();
15826                         }
15827                         return false;
15828
15829                 }
15830                 template<typename V> bool encode(size_t index, V& v) const
15831                 {
15832                         if(index != type) {return false;} return v(ref_nested());
15833
15834                 }
15835                 private:
15836                 size_t type {0};
15837
15838         };
15839         struct Extension_t : asn::typefield<true>
15840         {
15841                 ~Extension_t()  {clear();}
15842                 size_t get_index() const {return type;}
15843                 bool is_unknown() const { return type == 1; }
15844                 void clear()
15845                 {
15846                         type = 0; ref_nested().clear();
15847                 }
15848                 template<typename V> static inline void enumerate(V& v)
15849                 {
15850
15851                 }
15852                 protected:
15853                 template<typename V> bool decode(size_t index, V& v)
15854                 {
15855                         clear();
15856                         switch(index)
15857                         {
15858                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
15859                         }
15860                         return false;
15861
15862                 }
15863                 template<typename V> bool encode(size_t index, V& v) const
15864                 {
15865                         if(index != type) return false;
15866                         return false;
15867
15868                 }
15869                 private:
15870                 size_t type {0};
15871
15872         };
15873         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15874         {
15875                 size_t get_index() const {return type;}
15876                 bool is_unknown() const { return type == 1; }
15877                 void clear() {type = 0;}
15878                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15879                 template<typename V>  bool decode(V& v)
15880                 {
15881                         clear();
15882                         if(!v(ref_nested())) return false;
15883                         { type = 1; return true;}
15884                         return false;
15885
15886                 }
15887                 template<typename V> bool encode(V& v) const
15888                 {
15889                         return v(ref_nested());
15890
15891                 }
15892                 protected:
15893                 template<typename V>  bool decode(size_t index, V& v)
15894                 {
15895                         clear();
15896                         switch(index)
15897                         {
15898                         case 1: type = 1; return v(ref_nested());
15899                         ref_nested().clear();
15900                         }
15901                         return false;
15902
15903                 }
15904                 template<typename V> bool encode(size_t index, V& v) const
15905                 {
15906                         if(index != type) {return false;} return v(ref_nested());
15907
15908                 }
15909                 private:
15910                 size_t type {0};
15911
15912         };
15913
15914 };
15915 /*
15916 E-RABs-ToBeAdded-Item-Split-Bearer ::= SEQUENCE {
15917         e-RAB-ID                                                E-RAB-ID,
15918         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
15919         meNB-GTPtunnelEndpoint                  GTPtunnelEndpoint,
15920         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-Item-Split-BearerExtIEs} } OPTIONAL,
15921         ...
15922 }
15923 */
15924
15925 struct E_RABs_ToBeAdded_Item_Split_Bearer : asn::sequence<4, 0, true, 1>
15926 {
15927         static constexpr const char* name() {return "E-RABs-ToBeAdded-Item-Split-Bearer";}
15928         using parent_t = asn::sequence<4, 0, true, 1>;
15929         struct e_RAB_ID_t : E_RAB_ID
15930         {
15931                 static constexpr const char* name() {return "e_RAB_ID_t";}
15932                 using parent_t = E_RAB_ID;
15933
15934         };
15935         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15936         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15937         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
15938         {
15939                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
15940                 using parent_t = E_RAB_Level_QoS_Parameters;
15941
15942         };
15943         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
15944         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
15945         struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
15946         {
15947                 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
15948                 using parent_t = GTPtunnelEndpoint;
15949
15950         };
15951         meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
15952         meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
15953         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>
15954         {
15955                 static constexpr const char* name() {return "iE_Extensions_t";}
15956                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_Item_Split_BearerExtIEs>;
15957                 static constexpr bool optional = true;
15958
15959         };
15960         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15961         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15962         template<typename V> void decode(V& v)
15963         {
15964                 v(e_RAB_ID);
15965                 v(e_RAB_Level_QoS_Parameters);
15966                 v(meNB_GTPtunnelEndpoint);
15967                 v(iE_Extensions);
15968
15969         };
15970         template<typename V> void encode(V& v) const
15971         {
15972                 v(e_RAB_ID);
15973                 v(e_RAB_Level_QoS_Parameters);
15974                 v(meNB_GTPtunnelEndpoint);
15975                 v(iE_Extensions);
15976
15977         };
15978         void clear()
15979         {
15980                 e_RAB_ID.clear();
15981                 e_RAB_Level_QoS_Parameters.clear();
15982                 meNB_GTPtunnelEndpoint.clear();
15983                 iE_Extensions.clear();
15984
15985         };
15986         private:
15987         e_RAB_ID_t      e_RAB_ID;
15988         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
15989         meNB_GTPtunnelEndpoint_t        meNB_GTPtunnelEndpoint;
15990         iE_Extensions_t iE_Extensions;
15991
15992 };
15993 /*
15994 E-RABs-ToBeAdded-Item ::= CHOICE {
15995         sCG-Bearer              E-RABs-ToBeAdded-Item-SCG-Bearer,
15996         split-Bearer    E-RABs-ToBeAdded-Item-Split-Bearer,
15997         ...
15998 }
15999 */
16000
16001 struct E_RABs_ToBeAdded_Item : asn::choice<2, 0, true>
16002 {
16003         static constexpr const char* name() {return "E-RABs-ToBeAdded-Item";}
16004         using parent_t = asn::choice<2, 0, true>;
16005         index_type get_index() const {return index;}
16006         bool is_unknown() const {return index == 3;}
16007         void set_unknown() { set_index(3);  }
16008         ~E_RABs_ToBeAdded_Item() {clear();}
16009         struct sCG_Bearer_t : E_RABs_ToBeAdded_Item_SCG_Bearer
16010         {
16011                 static constexpr const char* name() {return "sCG_Bearer_t";}
16012                 using parent_t = E_RABs_ToBeAdded_Item_SCG_Bearer;
16013
16014         };
16015         struct split_Bearer_t : E_RABs_ToBeAdded_Item_Split_Bearer
16016         {
16017                 static constexpr const char* name() {return "split_Bearer_t";}
16018                 using parent_t = E_RABs_ToBeAdded_Item_Split_Bearer;
16019
16020         };
16021         void clear()
16022         {
16023                 switch(get_index())
16024                 {
16025                 case 1: var.destroy<sCG_Bearer_t>(); break;
16026                 case 2: var.destroy<split_Bearer_t>(); break;
16027                 }
16028                 index = 0;
16029                 base::clear();
16030         }
16031         template<typename V> bool decode(size_t idx, V& v)
16032         {
16033                 clear();
16034                 switch(idx)
16035                 {
16036                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
16037                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
16038                 }
16039                 return false;
16040
16041         }
16042         template<typename V> bool encode(V& v) const
16043         {
16044                 switch(get_index())
16045                 {
16046                 case 1: return v(var.as<sCG_Bearer_t>());
16047                 case 2: return v(var.as<split_Bearer_t>());
16048                 }
16049                 return false;
16050         }
16051         template<typename V> static inline void enumerate(V& v)
16052         {
16053                 v.template operator()<sCG_Bearer_t>(1);
16054                 v.template operator()<split_Bearer_t>(2);
16055
16056         }
16057         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
16058         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
16059         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
16060         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
16061         private:
16062         void set_index(index_type i) {index = i; base::set();}
16063         union union_type
16064         {
16065                 char dummy1[sizeof(sCG_Bearer_t)];
16066                 char dummy2[sizeof(split_Bearer_t)];
16067
16068         };
16069         asn::variant<sizeof(union_type)>        var;
16070         index_type      index {0};
16071 };
16072 /*
16073 E-RABs-ToBeAdded-ItemIEs X2AP-PROTOCOL-IES ::= {
16074         { ID id-E-RABs-ToBeAdded-Item   CRITICALITY reject      TYPE E-RABs-ToBeAdded-Item              PRESENCE mandatory},
16075         ...
16076 }
16077 */
16078
16079 struct E_RABs_ToBeAdded_ItemIEs
16080 {
16081         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
16082         {
16083                 size_t get_index() const {return type;}
16084                 bool is_unknown() const { return type == 2; }
16085                 void clear() {type = 0;}
16086                 void select_id_E_RABs_ToBeAdded_Item() { set(id_E_RABs_ToBeAdded_Item); type=1;}
16087                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
16088                 template<typename V>  bool decode(V& v)
16089                 {
16090                         clear();
16091                         if(!v(ref_nested())) return false;
16092                         if(equal(id_E_RABs_ToBeAdded_Item)) { type = 1; return true; }
16093                         else { type = 2; return true;}
16094                         return false;
16095
16096                 }
16097                 template<typename V> bool encode(V& v) const
16098                 {
16099                         return v(ref_nested());
16100
16101                 }
16102                 protected:
16103                 template<typename V>  bool decode(size_t index, V& v)
16104                 {
16105                         clear();
16106                         switch(index)
16107                         {
16108                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_Item);} return false;
16109                         case 2: type = 2; return v(ref_nested());
16110                         ref_nested().clear();
16111                         }
16112                         return false;
16113
16114                 }
16115                 template<typename V> bool encode(size_t index, V& v) const
16116                 {
16117                         if(index != type) {return false;} return v(ref_nested());
16118
16119                 }
16120                 private:
16121                 size_t type {0};
16122
16123         };
16124         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
16125         {
16126                 size_t get_index() const {return type;}
16127                 bool is_unknown() const { return type == 2; }
16128                 void clear() {type = 0;}
16129                 void select_id_E_RABs_ToBeAdded_Item() { set(reject); type=1;}
16130                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
16131                 template<typename V>  bool decode(V& v)
16132                 {
16133                         clear();
16134                         if(!v(ref_nested())) return false;
16135                         if(equal(reject)) { type = 1; return true; }
16136                         else { type = 2; return true;}
16137                         return false;
16138
16139                 }
16140                 template<typename V> bool encode(V& v) const
16141                 {
16142                         return v(ref_nested());
16143
16144                 }
16145                 protected:
16146                 template<typename V>  bool decode(size_t index, V& v)
16147                 {
16148                         clear();
16149                         switch(index)
16150                         {
16151                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
16152                         case 2: type = 2; return v(ref_nested());
16153                         ref_nested().clear();
16154                         }
16155                         return false;
16156
16157                 }
16158                 template<typename V> bool encode(size_t index, V& v) const
16159                 {
16160                         if(index != type) {return false;} return v(ref_nested());
16161
16162                 }
16163                 private:
16164                 size_t type {0};
16165
16166         };
16167         struct Value_t : asn::typefield<true>
16168         {
16169                 ~Value_t()      {clear();}
16170                 size_t get_index() const {return type;}
16171                 E_RABs_ToBeAdded_Item& select_id_E_RABs_ToBeAdded_Item() { return set<E_RABs_ToBeAdded_Item>(1); }
16172                 E_RABs_ToBeAdded_Item const* get_id_E_RABs_ToBeAdded_Item() const { return get<E_RABs_ToBeAdded_Item>(1); }
16173                 bool is_unknown() const { return type == 2; }
16174                 void clear()
16175                 {
16176                         switch(type)
16177                         {
16178                         case 1: var.destroy<E_RABs_ToBeAdded_Item>(); break;
16179                         }
16180                         type = 0; ref_nested().clear();
16181                 }
16182                 template<typename V> static inline void enumerate(V& v)
16183                 {
16184                         v.template operator()<E_RABs_ToBeAdded_Item>(1);
16185
16186                 }
16187                 protected:
16188                 template<typename V> bool decode(size_t index, V& v)
16189                 {
16190                         clear();
16191                         switch(index)
16192                         {
16193                         case 1: v(select_id_E_RABs_ToBeAdded_Item()); return true;
16194                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
16195                         }
16196                         return false;
16197
16198                 }
16199                 template<typename V> bool encode(size_t index, V& v) const
16200                 {
16201                         if(index != type) return false;
16202                         switch(type)
16203                         {
16204                         case 1: v(var.as<E_RABs_ToBeAdded_Item>()); return true;
16205                         }
16206                         return false;
16207
16208                 }
16209                 private:
16210                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16211                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16212                 union union_type
16213                 {
16214                         char dummy1[sizeof(E_RABs_ToBeAdded_Item)];
16215
16216                 };
16217                 asn::variant<sizeof(union_type)> var;
16218                 size_t type {0};
16219
16220         };
16221         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
16222         {
16223                 size_t get_index() const {return type;}
16224                 bool is_unknown() const { return type == 2; }
16225                 void clear() {type = 0;}
16226                 void select_id_E_RABs_ToBeAdded_Item() { set(mandatory); type=1;}
16227                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
16228                 template<typename V>  bool decode(V& v)
16229                 {
16230                         clear();
16231                         if(!v(ref_nested())) return false;
16232                         if(equal(mandatory)) { type = 1; return true; }
16233                         else { type = 2; return true;}
16234                         return false;
16235
16236                 }
16237                 template<typename V> bool encode(V& v) const
16238                 {
16239                         return v(ref_nested());
16240
16241                 }
16242                 protected:
16243                 template<typename V>  bool decode(size_t index, V& v)
16244                 {
16245                         clear();
16246                         switch(index)
16247                         {
16248                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
16249                         case 2: type = 2; return v(ref_nested());
16250                         ref_nested().clear();
16251                         }
16252                         return false;
16253
16254                 }
16255                 template<typename V> bool encode(size_t index, V& v) const
16256                 {
16257                         if(index != type) {return false;} return v(ref_nested());
16258
16259                 }
16260                 private:
16261                 size_t type {0};
16262
16263         };
16264
16265 };
16266 /*
16267 E-RABs-ToBeAdded-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ItemIEs} }
16268 */
16269
16270 struct E_RABs_ToBeAdded_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>
16271 {
16272         static constexpr const char* name() {return "E_RABs_ToBeAdded_List_elm";}
16273         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ItemIEs>;
16274
16275 };
16276 struct E_RABs_ToBeAdded_List : asn::sequenceof<E_RABs_ToBeAdded_List_elm>
16277 {
16278         static constexpr const char* name() {return "E-RABs-ToBeAdded-List";}
16279         using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_elm>;
16280         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
16281
16282 };
16283 /*
16284 E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16285         { ID id-Correlation-ID                          CRITICALITY ignore      EXTENSION Correlation-ID                PRESENCE optional}|
16286         { ID id-SIPTO-Correlation-ID            CRITICALITY ignore      EXTENSION Correlation-ID                PRESENCE optional},
16287         ...
16288 }
16289 */
16290
16291 struct E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs
16292 {
16293         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16294         {
16295                 size_t get_index() const {return type;}
16296                 bool is_unknown() const { return type == 3; }
16297                 void clear() {type = 0;}
16298                 void select_id_Correlation_ID() { set(id_Correlation_ID); type=1;}
16299                 void select_id_SIPTO_Correlation_ID() { set(id_SIPTO_Correlation_ID); type=2;}
16300                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16301                 template<typename V>  bool decode(V& v)
16302                 {
16303                         clear();
16304                         if(!v(ref_nested())) return false;
16305                         if(equal(id_Correlation_ID)) { type = 1; return true; }
16306                         else if(equal(id_SIPTO_Correlation_ID)) { type = 2; return true; }
16307                         else { type = 3; return true;}
16308                         return false;
16309
16310                 }
16311                 template<typename V> bool encode(V& v) const
16312                 {
16313                         return v(ref_nested());
16314
16315                 }
16316                 protected:
16317                 template<typename V>  bool decode(size_t index, V& v)
16318                 {
16319                         clear();
16320                         switch(index)
16321                         {
16322                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Correlation_ID);} return false;
16323                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SIPTO_Correlation_ID);} return false;
16324                         case 3: type = 3; return v(ref_nested());
16325                         ref_nested().clear();
16326                         }
16327                         return false;
16328
16329                 }
16330                 template<typename V> bool encode(size_t index, V& v) const
16331                 {
16332                         if(index != type) {return false;} return v(ref_nested());
16333
16334                 }
16335                 private:
16336                 size_t type {0};
16337
16338         };
16339         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16340         {
16341                 size_t get_index() const {return type;}
16342                 bool is_unknown() const { return type == 3; }
16343                 void clear() {type = 0;}
16344                 void select_id_Correlation_ID() { set(ignore); type=1;}
16345                 void select_id_SIPTO_Correlation_ID() { set(ignore); type=2;}
16346                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16347                 template<typename V>  bool decode(V& v)
16348                 {
16349                         clear();
16350                         if(!v(ref_nested())) return false;
16351                         if(equal(ignore)) { type = 1; return true; }
16352                         else if(equal(ignore)) { type = 2; return true; }
16353                         else { type = 3; return true;}
16354                         return false;
16355
16356                 }
16357                 template<typename V> bool encode(V& v) const
16358                 {
16359                         return v(ref_nested());
16360
16361                 }
16362                 protected:
16363                 template<typename V>  bool decode(size_t index, V& v)
16364                 {
16365                         clear();
16366                         switch(index)
16367                         {
16368                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16369                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
16370                         case 3: type = 3; return v(ref_nested());
16371                         ref_nested().clear();
16372                         }
16373                         return false;
16374
16375                 }
16376                 template<typename V> bool encode(size_t index, V& v) const
16377                 {
16378                         if(index != type) {return false;} return v(ref_nested());
16379
16380                 }
16381                 private:
16382                 size_t type {0};
16383
16384         };
16385         struct Extension_t : asn::typefield<true>
16386         {
16387                 ~Extension_t()  {clear();}
16388                 size_t get_index() const {return type;}
16389                 Correlation_ID& select_id_Correlation_ID() { return set<Correlation_ID>(1); }
16390                 Correlation_ID const* get_id_Correlation_ID() const { return get<Correlation_ID>(1); }
16391                 Correlation_ID& select_id_SIPTO_Correlation_ID() { return set<Correlation_ID>(2); }
16392                 Correlation_ID const* get_id_SIPTO_Correlation_ID() const { return get<Correlation_ID>(2); }
16393                 bool is_unknown() const { return type == 3; }
16394                 void clear()
16395                 {
16396                         switch(type)
16397                         {
16398                         case 1: var.destroy<Correlation_ID>(); break;
16399                         case 2: var.destroy<Correlation_ID>(); break;
16400                         }
16401                         type = 0; ref_nested().clear();
16402                 }
16403                 template<typename V> static inline void enumerate(V& v)
16404                 {
16405                         v.template operator()<Correlation_ID>(1);
16406                         v.template operator()<Correlation_ID>(2);
16407
16408                 }
16409                 protected:
16410                 template<typename V> bool decode(size_t index, V& v)
16411                 {
16412                         clear();
16413                         switch(index)
16414                         {
16415                         case 1: v(select_id_Correlation_ID()); return true;
16416                         case 2: v(select_id_SIPTO_Correlation_ID()); return true;
16417                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
16418                         }
16419                         return false;
16420
16421                 }
16422                 template<typename V> bool encode(size_t index, V& v) const
16423                 {
16424                         if(index != type) return false;
16425                         switch(type)
16426                         {
16427                         case 1: v(var.as<Correlation_ID>()); return true;
16428                         case 2: v(var.as<Correlation_ID>()); return true;
16429                         }
16430                         return false;
16431
16432                 }
16433                 private:
16434                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16435                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16436                 union union_type
16437                 {
16438                         char dummy1[sizeof(Correlation_ID)];
16439
16440                 };
16441                 asn::variant<sizeof(union_type)> var;
16442                 size_t type {0};
16443
16444         };
16445         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16446         {
16447                 size_t get_index() const {return type;}
16448                 bool is_unknown() const { return type == 3; }
16449                 void clear() {type = 0;}
16450                 void select_id_Correlation_ID() { set(optional); type=1;}
16451                 void select_id_SIPTO_Correlation_ID() { set(optional); type=2;}
16452                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16453                 template<typename V>  bool decode(V& v)
16454                 {
16455                         clear();
16456                         if(!v(ref_nested())) return false;
16457                         if(equal(optional)) { type = 1; return true; }
16458                         else if(equal(optional)) { type = 2; return true; }
16459                         else { type = 3; return true;}
16460                         return false;
16461
16462                 }
16463                 template<typename V> bool encode(V& v) const
16464                 {
16465                         return v(ref_nested());
16466
16467                 }
16468                 protected:
16469                 template<typename V>  bool decode(size_t index, V& v)
16470                 {
16471                         clear();
16472                         switch(index)
16473                         {
16474                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
16475                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
16476                         case 3: type = 3; return v(ref_nested());
16477                         ref_nested().clear();
16478                         }
16479                         return false;
16480
16481                 }
16482                 template<typename V> bool encode(size_t index, V& v) const
16483                 {
16484                         if(index != type) {return false;} return v(ref_nested());
16485
16486                 }
16487                 private:
16488                 size_t type {0};
16489
16490         };
16491
16492 };
16493 /*
16494 E-RABs-ToBeAdded-ModReqItem-SCG-Bearer ::= SEQUENCE {
16495         e-RAB-ID                                                E-RAB-ID,
16496         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
16497         dL-Forwarding                                   DL-Forwarding                                                                                                                                   OPTIONAL,
16498         s1-UL-GTPtunnelEndpoint                 GTPtunnelEndpoint,
16499         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
16500         ...
16501 }
16502 */
16503
16504 struct E_RABs_ToBeAdded_ModReqItem_SCG_Bearer : asn::sequence<5, 0, true, 2>
16505 {
16506         static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-SCG-Bearer";}
16507         using parent_t = asn::sequence<5, 0, true, 2>;
16508         struct e_RAB_ID_t : E_RAB_ID
16509         {
16510                 static constexpr const char* name() {return "e_RAB_ID_t";}
16511                 using parent_t = E_RAB_ID;
16512
16513         };
16514         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
16515         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
16516         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
16517         {
16518                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
16519                 using parent_t = E_RAB_Level_QoS_Parameters;
16520
16521         };
16522         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
16523         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
16524         struct dL_Forwarding_t : DL_Forwarding
16525         {
16526                 static constexpr const char* name() {return "dL_Forwarding_t";}
16527                 using parent_t = DL_Forwarding;
16528                 static constexpr bool optional = true;
16529
16530         };
16531         dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
16532         dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
16533         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
16534         {
16535                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
16536                 using parent_t = GTPtunnelEndpoint;
16537
16538         };
16539         s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
16540         s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
16541         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>
16542         {
16543                 static constexpr const char* name() {return "iE_Extensions_t";}
16544                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_SCG_BearerExtIEs>;
16545                 static constexpr bool optional = true;
16546
16547         };
16548         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16549         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16550         template<typename V> void decode(V& v)
16551         {
16552                 v(e_RAB_ID);
16553                 v(e_RAB_Level_QoS_Parameters);
16554                 v(dL_Forwarding);
16555                 v(s1_UL_GTPtunnelEndpoint);
16556                 v(iE_Extensions);
16557
16558         };
16559         template<typename V> void encode(V& v) const
16560         {
16561                 v(e_RAB_ID);
16562                 v(e_RAB_Level_QoS_Parameters);
16563                 v(dL_Forwarding);
16564                 v(s1_UL_GTPtunnelEndpoint);
16565                 v(iE_Extensions);
16566
16567         };
16568         void clear()
16569         {
16570                 e_RAB_ID.clear();
16571                 e_RAB_Level_QoS_Parameters.clear();
16572                 dL_Forwarding.clear();
16573                 s1_UL_GTPtunnelEndpoint.clear();
16574                 iE_Extensions.clear();
16575
16576         };
16577         private:
16578         e_RAB_ID_t      e_RAB_ID;
16579         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
16580         dL_Forwarding_t dL_Forwarding;
16581         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
16582         iE_Extensions_t iE_Extensions;
16583
16584 };
16585 /*
16586 E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16587         ...
16588 }
16589 */
16590
16591 struct E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs
16592 {
16593         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16594         {
16595                 size_t get_index() const {return type;}
16596                 bool is_unknown() const { return type == 1; }
16597                 void clear() {type = 0;}
16598                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16599                 template<typename V>  bool decode(V& v)
16600                 {
16601                         clear();
16602                         if(!v(ref_nested())) return false;
16603                         { type = 1; return true;}
16604                         return false;
16605
16606                 }
16607                 template<typename V> bool encode(V& v) const
16608                 {
16609                         return v(ref_nested());
16610
16611                 }
16612                 protected:
16613                 template<typename V>  bool decode(size_t index, V& v)
16614                 {
16615                         clear();
16616                         switch(index)
16617                         {
16618                         case 1: type = 1; return v(ref_nested());
16619                         ref_nested().clear();
16620                         }
16621                         return false;
16622
16623                 }
16624                 template<typename V> bool encode(size_t index, V& v) const
16625                 {
16626                         if(index != type) {return false;} return v(ref_nested());
16627
16628                 }
16629                 private:
16630                 size_t type {0};
16631
16632         };
16633         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16634         {
16635                 size_t get_index() const {return type;}
16636                 bool is_unknown() const { return type == 1; }
16637                 void clear() {type = 0;}
16638                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16639                 template<typename V>  bool decode(V& v)
16640                 {
16641                         clear();
16642                         if(!v(ref_nested())) return false;
16643                         { type = 1; return true;}
16644                         return false;
16645
16646                 }
16647                 template<typename V> bool encode(V& v) const
16648                 {
16649                         return v(ref_nested());
16650
16651                 }
16652                 protected:
16653                 template<typename V>  bool decode(size_t index, V& v)
16654                 {
16655                         clear();
16656                         switch(index)
16657                         {
16658                         case 1: type = 1; return v(ref_nested());
16659                         ref_nested().clear();
16660                         }
16661                         return false;
16662
16663                 }
16664                 template<typename V> bool encode(size_t index, V& v) const
16665                 {
16666                         if(index != type) {return false;} return v(ref_nested());
16667
16668                 }
16669                 private:
16670                 size_t type {0};
16671
16672         };
16673         struct Extension_t : asn::typefield<true>
16674         {
16675                 ~Extension_t()  {clear();}
16676                 size_t get_index() const {return type;}
16677                 bool is_unknown() const { return type == 1; }
16678                 void clear()
16679                 {
16680                         type = 0; ref_nested().clear();
16681                 }
16682                 template<typename V> static inline void enumerate(V& v)
16683                 {
16684
16685                 }
16686                 protected:
16687                 template<typename V> bool decode(size_t index, V& v)
16688                 {
16689                         clear();
16690                         switch(index)
16691                         {
16692                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16693                         }
16694                         return false;
16695
16696                 }
16697                 template<typename V> bool encode(size_t index, V& v) const
16698                 {
16699                         if(index != type) return false;
16700                         return false;
16701
16702                 }
16703                 private:
16704                 size_t type {0};
16705
16706         };
16707         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16708         {
16709                 size_t get_index() const {return type;}
16710                 bool is_unknown() const { return type == 1; }
16711                 void clear() {type = 0;}
16712                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16713                 template<typename V>  bool decode(V& v)
16714                 {
16715                         clear();
16716                         if(!v(ref_nested())) return false;
16717                         { type = 1; return true;}
16718                         return false;
16719
16720                 }
16721                 template<typename V> bool encode(V& v) const
16722                 {
16723                         return v(ref_nested());
16724
16725                 }
16726                 protected:
16727                 template<typename V>  bool decode(size_t index, V& v)
16728                 {
16729                         clear();
16730                         switch(index)
16731                         {
16732                         case 1: type = 1; return v(ref_nested());
16733                         ref_nested().clear();
16734                         }
16735                         return false;
16736
16737                 }
16738                 template<typename V> bool encode(size_t index, V& v) const
16739                 {
16740                         if(index != type) {return false;} return v(ref_nested());
16741
16742                 }
16743                 private:
16744                 size_t type {0};
16745
16746         };
16747
16748 };
16749 /*
16750 E-RABs-ToBeAdded-ModReqItem-Split-Bearer ::= SEQUENCE {
16751         e-RAB-ID                                                E-RAB-ID,
16752         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
16753         meNB-GTPtunnelEndpoint                  GTPtunnelEndpoint,
16754         iE-Extensions                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
16755         ...
16756 }
16757 */
16758
16759 struct E_RABs_ToBeAdded_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 1>
16760 {
16761         static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem-Split-Bearer";}
16762         using parent_t = asn::sequence<4, 0, true, 1>;
16763         struct e_RAB_ID_t : E_RAB_ID
16764         {
16765                 static constexpr const char* name() {return "e_RAB_ID_t";}
16766                 using parent_t = E_RAB_ID;
16767
16768         };
16769         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
16770         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
16771         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
16772         {
16773                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
16774                 using parent_t = E_RAB_Level_QoS_Parameters;
16775
16776         };
16777         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
16778         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
16779         struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
16780         {
16781                 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
16782                 using parent_t = GTPtunnelEndpoint;
16783
16784         };
16785         meNB_GTPtunnelEndpoint_t& ref_meNB_GTPtunnelEndpoint() {return meNB_GTPtunnelEndpoint;}
16786         meNB_GTPtunnelEndpoint_t const& ref_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint;}
16787         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>
16788         {
16789                 static constexpr const char* name() {return "iE_Extensions_t";}
16790                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_ModReqItem_Split_BearerExtIEs>;
16791                 static constexpr bool optional = true;
16792
16793         };
16794         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16795         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16796         template<typename V> void decode(V& v)
16797         {
16798                 v(e_RAB_ID);
16799                 v(e_RAB_Level_QoS_Parameters);
16800                 v(meNB_GTPtunnelEndpoint);
16801                 v(iE_Extensions);
16802
16803         };
16804         template<typename V> void encode(V& v) const
16805         {
16806                 v(e_RAB_ID);
16807                 v(e_RAB_Level_QoS_Parameters);
16808                 v(meNB_GTPtunnelEndpoint);
16809                 v(iE_Extensions);
16810
16811         };
16812         void clear()
16813         {
16814                 e_RAB_ID.clear();
16815                 e_RAB_Level_QoS_Parameters.clear();
16816                 meNB_GTPtunnelEndpoint.clear();
16817                 iE_Extensions.clear();
16818
16819         };
16820         private:
16821         e_RAB_ID_t      e_RAB_ID;
16822         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
16823         meNB_GTPtunnelEndpoint_t        meNB_GTPtunnelEndpoint;
16824         iE_Extensions_t iE_Extensions;
16825
16826 };
16827 /*
16828 E-RABs-ToBeAdded-ModReqItem ::= CHOICE {
16829         sCG-Bearer              E-RABs-ToBeAdded-ModReqItem-SCG-Bearer,
16830         split-Bearer    E-RABs-ToBeAdded-ModReqItem-Split-Bearer,
16831         ...
16832 }
16833 */
16834
16835 struct E_RABs_ToBeAdded_ModReqItem : asn::choice<2, 0, true>
16836 {
16837         static constexpr const char* name() {return "E-RABs-ToBeAdded-ModReqItem";}
16838         using parent_t = asn::choice<2, 0, true>;
16839         index_type get_index() const {return index;}
16840         bool is_unknown() const {return index == 3;}
16841         void set_unknown() { set_index(3);  }
16842         ~E_RABs_ToBeAdded_ModReqItem() {clear();}
16843         struct sCG_Bearer_t : E_RABs_ToBeAdded_ModReqItem_SCG_Bearer
16844         {
16845                 static constexpr const char* name() {return "sCG_Bearer_t";}
16846                 using parent_t = E_RABs_ToBeAdded_ModReqItem_SCG_Bearer;
16847
16848         };
16849         struct split_Bearer_t : E_RABs_ToBeAdded_ModReqItem_Split_Bearer
16850         {
16851                 static constexpr const char* name() {return "split_Bearer_t";}
16852                 using parent_t = E_RABs_ToBeAdded_ModReqItem_Split_Bearer;
16853
16854         };
16855         void clear()
16856         {
16857                 switch(get_index())
16858                 {
16859                 case 1: var.destroy<sCG_Bearer_t>(); break;
16860                 case 2: var.destroy<split_Bearer_t>(); break;
16861                 }
16862                 index = 0;
16863                 base::clear();
16864         }
16865         template<typename V> bool decode(size_t idx, V& v)
16866         {
16867                 clear();
16868                 switch(idx)
16869                 {
16870                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
16871                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
16872                 }
16873                 return false;
16874
16875         }
16876         template<typename V> bool encode(V& v) const
16877         {
16878                 switch(get_index())
16879                 {
16880                 case 1: return v(var.as<sCG_Bearer_t>());
16881                 case 2: return v(var.as<split_Bearer_t>());
16882                 }
16883                 return false;
16884         }
16885         template<typename V> static inline void enumerate(V& v)
16886         {
16887                 v.template operator()<sCG_Bearer_t>(1);
16888                 v.template operator()<split_Bearer_t>(2);
16889
16890         }
16891         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
16892         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
16893         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
16894         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
16895         private:
16896         void set_index(index_type i) {index = i; base::set();}
16897         union union_type
16898         {
16899                 char dummy1[sizeof(sCG_Bearer_t)];
16900                 char dummy2[sizeof(split_Bearer_t)];
16901
16902         };
16903         asn::variant<sizeof(union_type)>        var;
16904         index_type      index {0};
16905 };
16906 /*
16907 E-RABs-ToBeAdded-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
16908         { ID id-E-RABs-ToBeAdded-ModReqItem     CRITICALITY ignore      TYPE E-RABs-ToBeAdded-ModReqItem        PRESENCE mandatory},
16909         ...
16910 }
16911 */
16912
16913 struct E_RABs_ToBeAdded_ModReqItemIEs
16914 {
16915         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
16916         {
16917                 size_t get_index() const {return type;}
16918                 bool is_unknown() const { return type == 2; }
16919                 void clear() {type = 0;}
16920                 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(id_E_RABs_ToBeAdded_ModReqItem); type=1;}
16921                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
16922                 template<typename V>  bool decode(V& v)
16923                 {
16924                         clear();
16925                         if(!v(ref_nested())) return false;
16926                         if(equal(id_E_RABs_ToBeAdded_ModReqItem)) { type = 1; return true; }
16927                         else { type = 2; return true;}
16928                         return false;
16929
16930                 }
16931                 template<typename V> bool encode(V& v) const
16932                 {
16933                         return v(ref_nested());
16934
16935                 }
16936                 protected:
16937                 template<typename V>  bool decode(size_t index, V& v)
16938                 {
16939                         clear();
16940                         switch(index)
16941                         {
16942                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_ModReqItem);} return false;
16943                         case 2: type = 2; return v(ref_nested());
16944                         ref_nested().clear();
16945                         }
16946                         return false;
16947
16948                 }
16949                 template<typename V> bool encode(size_t index, V& v) const
16950                 {
16951                         if(index != type) {return false;} return v(ref_nested());
16952
16953                 }
16954                 private:
16955                 size_t type {0};
16956
16957         };
16958         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
16959         {
16960                 size_t get_index() const {return type;}
16961                 bool is_unknown() const { return type == 2; }
16962                 void clear() {type = 0;}
16963                 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(ignore); type=1;}
16964                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
16965                 template<typename V>  bool decode(V& v)
16966                 {
16967                         clear();
16968                         if(!v(ref_nested())) return false;
16969                         if(equal(ignore)) { type = 1; return true; }
16970                         else { type = 2; return true;}
16971                         return false;
16972
16973                 }
16974                 template<typename V> bool encode(V& v) const
16975                 {
16976                         return v(ref_nested());
16977
16978                 }
16979                 protected:
16980                 template<typename V>  bool decode(size_t index, V& v)
16981                 {
16982                         clear();
16983                         switch(index)
16984                         {
16985                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16986                         case 2: type = 2; return v(ref_nested());
16987                         ref_nested().clear();
16988                         }
16989                         return false;
16990
16991                 }
16992                 template<typename V> bool encode(size_t index, V& v) const
16993                 {
16994                         if(index != type) {return false;} return v(ref_nested());
16995
16996                 }
16997                 private:
16998                 size_t type {0};
16999
17000         };
17001         struct Value_t : asn::typefield<true>
17002         {
17003                 ~Value_t()      {clear();}
17004                 size_t get_index() const {return type;}
17005                 E_RABs_ToBeAdded_ModReqItem& select_id_E_RABs_ToBeAdded_ModReqItem() { return set<E_RABs_ToBeAdded_ModReqItem>(1); }
17006                 E_RABs_ToBeAdded_ModReqItem const* get_id_E_RABs_ToBeAdded_ModReqItem() const { return get<E_RABs_ToBeAdded_ModReqItem>(1); }
17007                 bool is_unknown() const { return type == 2; }
17008                 void clear()
17009                 {
17010                         switch(type)
17011                         {
17012                         case 1: var.destroy<E_RABs_ToBeAdded_ModReqItem>(); break;
17013                         }
17014                         type = 0; ref_nested().clear();
17015                 }
17016                 template<typename V> static inline void enumerate(V& v)
17017                 {
17018                         v.template operator()<E_RABs_ToBeAdded_ModReqItem>(1);
17019
17020                 }
17021                 protected:
17022                 template<typename V> bool decode(size_t index, V& v)
17023                 {
17024                         clear();
17025                         switch(index)
17026                         {
17027                         case 1: v(select_id_E_RABs_ToBeAdded_ModReqItem()); return true;
17028                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
17029                         }
17030                         return false;
17031
17032                 }
17033                 template<typename V> bool encode(size_t index, V& v) const
17034                 {
17035                         if(index != type) return false;
17036                         switch(type)
17037                         {
17038                         case 1: v(var.as<E_RABs_ToBeAdded_ModReqItem>()); return true;
17039                         }
17040                         return false;
17041
17042                 }
17043                 private:
17044                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17045                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17046                 union union_type
17047                 {
17048                         char dummy1[sizeof(E_RABs_ToBeAdded_ModReqItem)];
17049
17050                 };
17051                 asn::variant<sizeof(union_type)> var;
17052                 size_t type {0};
17053
17054         };
17055         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
17056         {
17057                 size_t get_index() const {return type;}
17058                 bool is_unknown() const { return type == 2; }
17059                 void clear() {type = 0;}
17060                 void select_id_E_RABs_ToBeAdded_ModReqItem() { set(mandatory); type=1;}
17061                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
17062                 template<typename V>  bool decode(V& v)
17063                 {
17064                         clear();
17065                         if(!v(ref_nested())) return false;
17066                         if(equal(mandatory)) { type = 1; return true; }
17067                         else { type = 2; return true;}
17068                         return false;
17069
17070                 }
17071                 template<typename V> bool encode(V& v) const
17072                 {
17073                         return v(ref_nested());
17074
17075                 }
17076                 protected:
17077                 template<typename V>  bool decode(size_t index, V& v)
17078                 {
17079                         clear();
17080                         switch(index)
17081                         {
17082                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
17083                         case 2: type = 2; return v(ref_nested());
17084                         ref_nested().clear();
17085                         }
17086                         return false;
17087
17088                 }
17089                 template<typename V> bool encode(size_t index, V& v) const
17090                 {
17091                         if(index != type) {return false;} return v(ref_nested());
17092
17093                 }
17094                 private:
17095                 size_t type {0};
17096
17097         };
17098
17099 };
17100 /*
17101 E-RABs-ToBeAdded-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-ModReqItemIEs} }
17102 */
17103
17104 struct E_RABs_ToBeAdded_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>
17105 {
17106         static constexpr const char* name() {return "E_RABs_ToBeAdded_List_ModReq_elm";}
17107         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_ModReqItemIEs>;
17108
17109 };
17110 struct E_RABs_ToBeAdded_List_ModReq : asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>
17111 {
17112         static constexpr const char* name() {return "E-RABs-ToBeAdded-List-ModReq";}
17113         using parent_t = asn::sequenceof<E_RABs_ToBeAdded_List_ModReq_elm>;
17114         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
17115
17116 };
17117 /*
17118 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17119         { ID id-RLCMode-transferred                                     CRITICALITY ignore      EXTENSION RLCMode                                       PRESENCE optional},
17120         ...
17121 }
17122 */
17123
17124 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs
17125 {
17126         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17127         {
17128                 size_t get_index() const {return type;}
17129                 bool is_unknown() const { return type == 2; }
17130                 void clear() {type = 0;}
17131                 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
17132                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17133                 template<typename V>  bool decode(V& v)
17134                 {
17135                         clear();
17136                         if(!v(ref_nested())) return false;
17137                         if(equal(id_RLCMode_transferred)) { type = 1; return true; }
17138                         else { type = 2; return true;}
17139                         return false;
17140
17141                 }
17142                 template<typename V> bool encode(V& v) const
17143                 {
17144                         return v(ref_nested());
17145
17146                 }
17147                 protected:
17148                 template<typename V>  bool decode(size_t index, V& v)
17149                 {
17150                         clear();
17151                         switch(index)
17152                         {
17153                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
17154                         case 2: type = 2; return v(ref_nested());
17155                         ref_nested().clear();
17156                         }
17157                         return false;
17158
17159                 }
17160                 template<typename V> bool encode(size_t index, V& v) const
17161                 {
17162                         if(index != type) {return false;} return v(ref_nested());
17163
17164                 }
17165                 private:
17166                 size_t type {0};
17167
17168         };
17169         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17170         {
17171                 size_t get_index() const {return type;}
17172                 bool is_unknown() const { return type == 2; }
17173                 void clear() {type = 0;}
17174                 void select_id_RLCMode_transferred() { set(ignore); type=1;}
17175                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17176                 template<typename V>  bool decode(V& v)
17177                 {
17178                         clear();
17179                         if(!v(ref_nested())) return false;
17180                         if(equal(ignore)) { type = 1; return true; }
17181                         else { type = 2; return true;}
17182                         return false;
17183
17184                 }
17185                 template<typename V> bool encode(V& v) const
17186                 {
17187                         return v(ref_nested());
17188
17189                 }
17190                 protected:
17191                 template<typename V>  bool decode(size_t index, V& v)
17192                 {
17193                         clear();
17194                         switch(index)
17195                         {
17196                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
17197                         case 2: type = 2; return v(ref_nested());
17198                         ref_nested().clear();
17199                         }
17200                         return false;
17201
17202                 }
17203                 template<typename V> bool encode(size_t index, V& v) const
17204                 {
17205                         if(index != type) {return false;} return v(ref_nested());
17206
17207                 }
17208                 private:
17209                 size_t type {0};
17210
17211         };
17212         struct Extension_t : asn::typefield<true>
17213         {
17214                 ~Extension_t()  {clear();}
17215                 size_t get_index() const {return type;}
17216                 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
17217                 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
17218                 bool is_unknown() const { return type == 2; }
17219                 void clear()
17220                 {
17221                         switch(type)
17222                         {
17223                         case 1: var.destroy<RLCMode>(); break;
17224                         }
17225                         type = 0; ref_nested().clear();
17226                 }
17227                 template<typename V> static inline void enumerate(V& v)
17228                 {
17229                         v.template operator()<RLCMode>(1);
17230
17231                 }
17232                 protected:
17233                 template<typename V> bool decode(size_t index, V& v)
17234                 {
17235                         clear();
17236                         switch(index)
17237                         {
17238                         case 1: v(select_id_RLCMode_transferred()); return true;
17239                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
17240                         }
17241                         return false;
17242
17243                 }
17244                 template<typename V> bool encode(size_t index, V& v) const
17245                 {
17246                         if(index != type) return false;
17247                         switch(type)
17248                         {
17249                         case 1: v(var.as<RLCMode>()); return true;
17250                         }
17251                         return false;
17252
17253                 }
17254                 private:
17255                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17256                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17257                 union union_type
17258                 {
17259                         char dummy1[sizeof(RLCMode)];
17260
17261                 };
17262                 asn::variant<sizeof(union_type)> var;
17263                 size_t type {0};
17264
17265         };
17266         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17267         {
17268                 size_t get_index() const {return type;}
17269                 bool is_unknown() const { return type == 2; }
17270                 void clear() {type = 0;}
17271                 void select_id_RLCMode_transferred() { set(optional); type=1;}
17272                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17273                 template<typename V>  bool decode(V& v)
17274                 {
17275                         clear();
17276                         if(!v(ref_nested())) return false;
17277                         if(equal(optional)) { type = 1; return true; }
17278                         else { type = 2; return true;}
17279                         return false;
17280
17281                 }
17282                 template<typename V> bool encode(V& v) const
17283                 {
17284                         return v(ref_nested());
17285
17286                 }
17287                 protected:
17288                 template<typename V>  bool decode(size_t index, V& v)
17289                 {
17290                         clear();
17291                         switch(index)
17292                         {
17293                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
17294                         case 2: type = 2; return v(ref_nested());
17295                         ref_nested().clear();
17296                         }
17297                         return false;
17298
17299                 }
17300                 template<typename V> bool encode(size_t index, V& v) const
17301                 {
17302                         if(index != type) {return false;} return v(ref_nested());
17303
17304                 }
17305                 private:
17306                 size_t type {0};
17307
17308         };
17309
17310 };
17311 /*
17312 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent ::= SEQUENCE {
17313         full-E-RAB-Level-QoS-Parameters                         E-RAB-Level-QoS-Parameters,
17314         max-MCG-admit-E-RAB-Level-QoS-Parameters        GBR-QosInformation                                                                                                                      OPTIONAL,
17315 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
17316         dL-Forwarding                                                           DL-Forwarding                                                                                                                                           OPTIONAL,
17317         meNB-DL-GTP-TEIDatMCG                                           GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
17318 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
17319         s1-UL-GTPtunnelEndpoint                                         GTPtunnelEndpoint,
17320         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
17321         ...
17322 }
17323 */
17324
17325 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
17326 {
17327         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent";}
17328         using parent_t = asn::sequence<6, 0, true, 4>;
17329         struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
17330         {
17331                 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
17332                 using parent_t = E_RAB_Level_QoS_Parameters;
17333
17334         };
17335         full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
17336         full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
17337         struct max_MCG_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
17338         {
17339                 static constexpr const char* name() {return "max_MCG_admit_E_RAB_Level_QoS_Parameters_t";}
17340                 using parent_t = GBR_QosInformation;
17341                 static constexpr bool optional = true;
17342
17343         };
17344         max_MCG_admit_E_RAB_Level_QoS_Parameters_t& set_max_MCG_admit_E_RAB_Level_QoS_Parameters() { max_MCG_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MCG_admit_E_RAB_Level_QoS_Parameters;}
17345         max_MCG_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MCG_admit_E_RAB_Level_QoS_Parameters() const {return max_MCG_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MCG_admit_E_RAB_Level_QoS_Parameters : nullptr;}
17346         struct dL_Forwarding_t : DL_Forwarding
17347         {
17348                 static constexpr const char* name() {return "dL_Forwarding_t";}
17349                 using parent_t = DL_Forwarding;
17350                 static constexpr bool optional = true;
17351
17352         };
17353         dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
17354         dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
17355         struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
17356         {
17357                 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
17358                 using parent_t = GTPtunnelEndpoint;
17359                 static constexpr bool optional = true;
17360
17361         };
17362         meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
17363         meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
17364         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
17365         {
17366                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
17367                 using parent_t = GTPtunnelEndpoint;
17368
17369         };
17370         s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
17371         s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
17372         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>
17373         {
17374                 static constexpr const char* name() {return "iE_Extensions_t";}
17375                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresentExtIEs>;
17376                 static constexpr bool optional = true;
17377
17378         };
17379         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17380         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17381         template<typename V> void decode(V& v)
17382         {
17383                 v(full_E_RAB_Level_QoS_Parameters);
17384                 v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
17385                 v(dL_Forwarding);
17386                 v(meNB_DL_GTP_TEIDatMCG);
17387                 v(s1_UL_GTPtunnelEndpoint);
17388                 v(iE_Extensions);
17389
17390         };
17391         template<typename V> void encode(V& v) const
17392         {
17393                 v(full_E_RAB_Level_QoS_Parameters);
17394                 v(max_MCG_admit_E_RAB_Level_QoS_Parameters);
17395                 v(dL_Forwarding);
17396                 v(meNB_DL_GTP_TEIDatMCG);
17397                 v(s1_UL_GTPtunnelEndpoint);
17398                 v(iE_Extensions);
17399
17400         };
17401         void clear()
17402         {
17403                 full_E_RAB_Level_QoS_Parameters.clear();
17404                 max_MCG_admit_E_RAB_Level_QoS_Parameters.clear();
17405                 dL_Forwarding.clear();
17406                 meNB_DL_GTP_TEIDatMCG.clear();
17407                 s1_UL_GTPtunnelEndpoint.clear();
17408                 iE_Extensions.clear();
17409
17410         };
17411         private:
17412         full_E_RAB_Level_QoS_Parameters_t       full_E_RAB_Level_QoS_Parameters;
17413         max_MCG_admit_E_RAB_Level_QoS_Parameters_t      max_MCG_admit_E_RAB_Level_QoS_Parameters;
17414         dL_Forwarding_t dL_Forwarding;
17415         meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
17416         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
17417         iE_Extensions_t iE_Extensions;
17418
17419 };
17420 /*
17421 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17422         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
17423         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
17424         { ID id-duplicationActivation                                   CRITICALITY ignore      EXTENSION DuplicationActivation PRESENCE optional},
17425         ...
17426 }
17427 */
17428
17429 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs
17430 {
17431         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17432         {
17433                 size_t get_index() const {return type;}
17434                 bool is_unknown() const { return type == 4; }
17435                 void clear() {type = 0;}
17436                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
17437                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
17438                 void select_id_duplicationActivation() { set(id_duplicationActivation); type=3;}
17439                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17440                 template<typename V>  bool decode(V& v)
17441                 {
17442                         clear();
17443                         if(!v(ref_nested())) return false;
17444                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
17445                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
17446                         else if(equal(id_duplicationActivation)) { type = 3; return true; }
17447                         else { type = 4; return true;}
17448                         return false;
17449
17450                 }
17451                 template<typename V> bool encode(V& v) const
17452                 {
17453                         return v(ref_nested());
17454
17455                 }
17456                 protected:
17457                 template<typename V>  bool decode(size_t index, V& v)
17458                 {
17459                         clear();
17460                         switch(index)
17461                         {
17462                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
17463                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
17464                         case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} return false;
17465                         case 4: type = 4; return v(ref_nested());
17466                         ref_nested().clear();
17467                         }
17468                         return false;
17469
17470                 }
17471                 template<typename V> bool encode(size_t index, V& v) const
17472                 {
17473                         if(index != type) {return false;} return v(ref_nested());
17474
17475                 }
17476                 private:
17477                 size_t type {0};
17478
17479         };
17480         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17481         {
17482                 size_t get_index() const {return type;}
17483                 bool is_unknown() const { return type == 4; }
17484                 void clear() {type = 0;}
17485                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
17486                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
17487                 void select_id_duplicationActivation() { set(ignore); type=3;}
17488                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17489                 template<typename V>  bool decode(V& v)
17490                 {
17491                         clear();
17492                         if(!v(ref_nested())) return false;
17493                         if(equal(ignore)) { type = 1; return true; }
17494                         else if(equal(ignore)) { type = 2; return true; }
17495                         else if(equal(ignore)) { type = 3; return true; }
17496                         else { type = 4; return true;}
17497                         return false;
17498
17499                 }
17500                 template<typename V> bool encode(V& v) const
17501                 {
17502                         return v(ref_nested());
17503
17504                 }
17505                 protected:
17506                 template<typename V>  bool decode(size_t index, V& v)
17507                 {
17508                         clear();
17509                         switch(index)
17510                         {
17511                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
17512                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
17513                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
17514                         case 4: type = 4; return v(ref_nested());
17515                         ref_nested().clear();
17516                         }
17517                         return false;
17518
17519                 }
17520                 template<typename V> bool encode(size_t index, V& v) const
17521                 {
17522                         if(index != type) {return false;} return v(ref_nested());
17523
17524                 }
17525                 private:
17526                 size_t type {0};
17527
17528         };
17529         struct Extension_t : asn::typefield<true>
17530         {
17531                 ~Extension_t()  {clear();}
17532                 size_t get_index() const {return type;}
17533                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
17534                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
17535                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
17536                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
17537                 DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
17538                 DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
17539                 bool is_unknown() const { return type == 4; }
17540                 void clear()
17541                 {
17542                         switch(type)
17543                         {
17544                         case 1: var.destroy<PDCPSnLength>(); break;
17545                         case 2: var.destroy<PDCPSnLength>(); break;
17546                         case 3: var.destroy<DuplicationActivation>(); break;
17547                         }
17548                         type = 0; ref_nested().clear();
17549                 }
17550                 template<typename V> static inline void enumerate(V& v)
17551                 {
17552                         v.template operator()<PDCPSnLength>(1);
17553                         v.template operator()<PDCPSnLength>(2);
17554                         v.template operator()<DuplicationActivation>(3);
17555
17556                 }
17557                 protected:
17558                 template<typename V> bool decode(size_t index, V& v)
17559                 {
17560                         clear();
17561                         switch(index)
17562                         {
17563                         case 1: v(select_id_uLpDCPSnLength()); return true;
17564                         case 2: v(select_id_dLPDCPSnLength()); return true;
17565                         case 3: v(select_id_duplicationActivation()); return true;
17566                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
17567                         }
17568                         return false;
17569
17570                 }
17571                 template<typename V> bool encode(size_t index, V& v) const
17572                 {
17573                         if(index != type) return false;
17574                         switch(type)
17575                         {
17576                         case 1: v(var.as<PDCPSnLength>()); return true;
17577                         case 2: v(var.as<PDCPSnLength>()); return true;
17578                         case 3: v(var.as<DuplicationActivation>()); return true;
17579                         }
17580                         return false;
17581
17582                 }
17583                 private:
17584                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
17585                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
17586                 union union_type
17587                 {
17588                         char dummy1[sizeof(DuplicationActivation)];
17589                         char dummy2[sizeof(PDCPSnLength)];
17590
17591                 };
17592                 asn::variant<sizeof(union_type)> var;
17593                 size_t type {0};
17594
17595         };
17596         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17597         {
17598                 size_t get_index() const {return type;}
17599                 bool is_unknown() const { return type == 4; }
17600                 void clear() {type = 0;}
17601                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
17602                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
17603                 void select_id_duplicationActivation() { set(optional); type=3;}
17604                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17605                 template<typename V>  bool decode(V& v)
17606                 {
17607                         clear();
17608                         if(!v(ref_nested())) return false;
17609                         if(equal(optional)) { type = 1; return true; }
17610                         else if(equal(optional)) { type = 2; return true; }
17611                         else if(equal(optional)) { type = 3; return true; }
17612                         else { type = 4; return true;}
17613                         return false;
17614
17615                 }
17616                 template<typename V> bool encode(V& v) const
17617                 {
17618                         return v(ref_nested());
17619
17620                 }
17621                 protected:
17622                 template<typename V>  bool decode(size_t index, V& v)
17623                 {
17624                         clear();
17625                         switch(index)
17626                         {
17627                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
17628                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
17629                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
17630                         case 4: type = 4; return v(ref_nested());
17631                         ref_nested().clear();
17632                         }
17633                         return false;
17634
17635                 }
17636                 template<typename V> bool encode(size_t index, V& v) const
17637                 {
17638                         if(index != type) {return false;} return v(ref_nested());
17639
17640                 }
17641                 private:
17642                 size_t type {0};
17643
17644         };
17645
17646 };
17647 /*
17648 E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
17649         requested-SCG-E-RAB-Level-QoS-Parameters                E-RAB-Level-QoS-Parameters,
17650         meNB-UL-GTP-TEIDatPDCP                                                  GTPtunnelEndpoint,
17651         secondary-meNB-UL-GTP-TEIDatPDCP                                GTPtunnelEndpoint       OPTIONAL,
17652         rlc-Mode                                                                                RLCMode,
17653         uL-Configuration                                                                ULConfiguration OPTIONAL,
17654 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
17655         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresentExtIEs} }               OPTIONAL,
17656         ...
17657 }
17658 */
17659
17660 struct E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
17661 {
17662         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent";}
17663         using parent_t = asn::sequence<6, 0, true, 3>;
17664         struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
17665         {
17666                 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
17667                 using parent_t = E_RAB_Level_QoS_Parameters;
17668
17669         };
17670         requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
17671         requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
17672         struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
17673         {
17674                 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
17675                 using parent_t = GTPtunnelEndpoint;
17676
17677         };
17678         meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
17679         meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
17680         struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
17681         {
17682                 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
17683                 using parent_t = GTPtunnelEndpoint;
17684                 static constexpr bool optional = true;
17685
17686         };
17687         secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
17688         secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
17689         struct rlc_Mode_t : RLCMode
17690         {
17691                 static constexpr const char* name() {return "rlc_Mode_t";}
17692                 using parent_t = RLCMode;
17693
17694         };
17695         rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
17696         rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
17697         struct uL_Configuration_t : ULConfiguration
17698         {
17699                 static constexpr const char* name() {return "uL_Configuration_t";}
17700                 using parent_t = ULConfiguration;
17701                 static constexpr bool optional = true;
17702
17703         };
17704         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
17705         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
17706         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>
17707         {
17708                 static constexpr const char* name() {return "iE_Extensions_t";}
17709                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresentExtIEs>;
17710                 static constexpr bool optional = true;
17711
17712         };
17713         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17714         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17715         template<typename V> void decode(V& v)
17716         {
17717                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
17718                 v(meNB_UL_GTP_TEIDatPDCP);
17719                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
17720                 v(rlc_Mode);
17721                 v(uL_Configuration);
17722                 v(iE_Extensions);
17723
17724         };
17725         template<typename V> void encode(V& v) const
17726         {
17727                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
17728                 v(meNB_UL_GTP_TEIDatPDCP);
17729                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
17730                 v(rlc_Mode);
17731                 v(uL_Configuration);
17732                 v(iE_Extensions);
17733
17734         };
17735         void clear()
17736         {
17737                 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
17738                 meNB_UL_GTP_TEIDatPDCP.clear();
17739                 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
17740                 rlc_Mode.clear();
17741                 uL_Configuration.clear();
17742                 iE_Extensions.clear();
17743
17744         };
17745         private:
17746         requested_SCG_E_RAB_Level_QoS_Parameters_t      requested_SCG_E_RAB_Level_QoS_Parameters;
17747         meNB_UL_GTP_TEIDatPDCP_t        meNB_UL_GTP_TEIDatPDCP;
17748         secondary_meNB_UL_GTP_TEIDatPDCP_t      secondary_meNB_UL_GTP_TEIDatPDCP;
17749         rlc_Mode_t      rlc_Mode;
17750         uL_Configuration_t      uL_Configuration;
17751         iE_Extensions_t iE_Extensions;
17752
17753 };
17754 /*
17755 E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17756         ...
17757 }
17758 */
17759
17760 struct E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs
17761 {
17762         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17763         {
17764                 size_t get_index() const {return type;}
17765                 bool is_unknown() const { return type == 1; }
17766                 void clear() {type = 0;}
17767                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17768                 template<typename V>  bool decode(V& v)
17769                 {
17770                         clear();
17771                         if(!v(ref_nested())) return false;
17772                         { type = 1; return true;}
17773                         return false;
17774
17775                 }
17776                 template<typename V> bool encode(V& v) const
17777                 {
17778                         return v(ref_nested());
17779
17780                 }
17781                 protected:
17782                 template<typename V>  bool decode(size_t index, V& v)
17783                 {
17784                         clear();
17785                         switch(index)
17786                         {
17787                         case 1: type = 1; return v(ref_nested());
17788                         ref_nested().clear();
17789                         }
17790                         return false;
17791
17792                 }
17793                 template<typename V> bool encode(size_t index, V& v) const
17794                 {
17795                         if(index != type) {return false;} return v(ref_nested());
17796
17797                 }
17798                 private:
17799                 size_t type {0};
17800
17801         };
17802         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17803         {
17804                 size_t get_index() const {return type;}
17805                 bool is_unknown() const { return type == 1; }
17806                 void clear() {type = 0;}
17807                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17808                 template<typename V>  bool decode(V& v)
17809                 {
17810                         clear();
17811                         if(!v(ref_nested())) return false;
17812                         { type = 1; return true;}
17813                         return false;
17814
17815                 }
17816                 template<typename V> bool encode(V& v) const
17817                 {
17818                         return v(ref_nested());
17819
17820                 }
17821                 protected:
17822                 template<typename V>  bool decode(size_t index, V& v)
17823                 {
17824                         clear();
17825                         switch(index)
17826                         {
17827                         case 1: type = 1; return v(ref_nested());
17828                         ref_nested().clear();
17829                         }
17830                         return false;
17831
17832                 }
17833                 template<typename V> bool encode(size_t index, V& v) const
17834                 {
17835                         if(index != type) {return false;} return v(ref_nested());
17836
17837                 }
17838                 private:
17839                 size_t type {0};
17840
17841         };
17842         struct Extension_t : asn::typefield<true>
17843         {
17844                 ~Extension_t()  {clear();}
17845                 size_t get_index() const {return type;}
17846                 bool is_unknown() const { return type == 1; }
17847                 void clear()
17848                 {
17849                         type = 0; ref_nested().clear();
17850                 }
17851                 template<typename V> static inline void enumerate(V& v)
17852                 {
17853
17854                 }
17855                 protected:
17856                 template<typename V> bool decode(size_t index, V& v)
17857                 {
17858                         clear();
17859                         switch(index)
17860                         {
17861                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17862                         }
17863                         return false;
17864
17865                 }
17866                 template<typename V> bool encode(size_t index, V& v) const
17867                 {
17868                         if(index != type) return false;
17869                         return false;
17870
17871                 }
17872                 private:
17873                 size_t type {0};
17874
17875         };
17876         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17877         {
17878                 size_t get_index() const {return type;}
17879                 bool is_unknown() const { return type == 1; }
17880                 void clear() {type = 0;}
17881                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17882                 template<typename V>  bool decode(V& v)
17883                 {
17884                         clear();
17885                         if(!v(ref_nested())) return false;
17886                         { type = 1; return true;}
17887                         return false;
17888
17889                 }
17890                 template<typename V> bool encode(V& v) const
17891                 {
17892                         return v(ref_nested());
17893
17894                 }
17895                 protected:
17896                 template<typename V>  bool decode(size_t index, V& v)
17897                 {
17898                         clear();
17899                         switch(index)
17900                         {
17901                         case 1: type = 1; return v(ref_nested());
17902                         ref_nested().clear();
17903                         }
17904                         return false;
17905
17906                 }
17907                 template<typename V> bool encode(size_t index, V& v) const
17908                 {
17909                         if(index != type) {return false;} return v(ref_nested());
17910
17911                 }
17912                 private:
17913                 size_t type {0};
17914
17915         };
17916
17917 };
17918 /*
17919 E-RABs-ToBeAdded-SgNBAddReq-Item ::= SEQUENCE {
17920         e-RAB-ID                                                                E-RAB-ID,
17921         drb-ID                                                          DRB-ID,
17922         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
17923         resource-configuration                          CHOICE {
17924                 sgNBPDCPpresent                                         E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPpresent,
17925                 sgNBPDCPnotpresent                                      E-RABs-ToBeAdded-SgNBAddReq-Item-SgNBPDCPnotpresent,
17926                 ...
17927         },
17928         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBAddReq-ItemExtIEs} } OPTIONAL,
17929         ...
17930 }
17931 */
17932
17933 struct E_RABs_ToBeAdded_SgNBAddReq_Item : asn::sequence<5, 0, true, 1>
17934 {
17935         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReq-Item";}
17936         using parent_t = asn::sequence<5, 0, true, 1>;
17937         struct e_RAB_ID_t : E_RAB_ID
17938         {
17939                 static constexpr const char* name() {return "e_RAB_ID_t";}
17940                 using parent_t = E_RAB_ID;
17941
17942         };
17943         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
17944         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
17945         struct drb_ID_t : DRB_ID
17946         {
17947                 static constexpr const char* name() {return "drb_ID_t";}
17948                 using parent_t = DRB_ID;
17949
17950         };
17951         drb_ID_t& ref_drb_ID() {return drb_ID;}
17952         drb_ID_t const& ref_drb_ID() const {return drb_ID;}
17953         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
17954         {
17955                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
17956                 using parent_t = EN_DC_ResourceConfiguration;
17957
17958         };
17959         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
17960         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
17961         struct resource_configuration_t : asn::choice<2, 0, true>
17962         {
17963                 static constexpr const char* name() {return "resource_configuration_t";}
17964                 using parent_t = asn::choice<2, 0, true>;
17965                 index_type get_index() const {return index;}
17966                 bool is_unknown() const {return index == 3;}
17967                 void set_unknown() { set_index(3);  }
17968                 ~resource_configuration_t() {clear();}
17969                 struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent
17970                 {
17971                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
17972                         using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent;
17973
17974                 };
17975                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent
17976                 {
17977                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
17978                         using parent_t = E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent;
17979
17980                 };
17981                 void clear()
17982                 {
17983                         switch(get_index())
17984                         {
17985                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
17986                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
17987                         }
17988                         index = 0;
17989                         base::clear();
17990                 }
17991                 template<typename V> bool decode(size_t idx, V& v)
17992                 {
17993                         clear();
17994                         switch(idx)
17995                         {
17996                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
17997                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
17998                         }
17999                         return false;
18000
18001                 }
18002                 template<typename V> bool encode(V& v) const
18003                 {
18004                         switch(get_index())
18005                         {
18006                         case 1: return v(var.as<sgNBPDCPpresent_t>());
18007                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
18008                         }
18009                         return false;
18010                 }
18011                 template<typename V> static inline void enumerate(V& v)
18012                 {
18013                         v.template operator()<sgNBPDCPpresent_t>(1);
18014                         v.template operator()<sgNBPDCPnotpresent_t>(2);
18015
18016                 }
18017                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
18018                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
18019                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
18020                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
18021                 private:
18022                 void set_index(index_type i) {index = i; base::set();}
18023                 union union_type
18024                 {
18025                         char dummy1[sizeof(sgNBPDCPpresent_t)];
18026                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
18027
18028                 };
18029                 asn::variant<sizeof(union_type)>        var;
18030                 index_type      index {0};
18031         };
18032         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
18033         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
18034         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>
18035         {
18036                 static constexpr const char* name() {return "iE_Extensions_t";}
18037                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBAddReq_ItemExtIEs>;
18038                 static constexpr bool optional = true;
18039
18040         };
18041         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18042         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18043         template<typename V> void decode(V& v)
18044         {
18045                 v(e_RAB_ID);
18046                 v(drb_ID);
18047                 v(en_DC_ResourceConfiguration);
18048                 v(resource_configuration);
18049                 v(iE_Extensions);
18050
18051         };
18052         template<typename V> void encode(V& v) const
18053         {
18054                 v(e_RAB_ID);
18055                 v(drb_ID);
18056                 v(en_DC_ResourceConfiguration);
18057                 v(resource_configuration);
18058                 v(iE_Extensions);
18059
18060         };
18061         void clear()
18062         {
18063                 e_RAB_ID.clear();
18064                 drb_ID.clear();
18065                 en_DC_ResourceConfiguration.clear();
18066                 resource_configuration.clear();
18067                 iE_Extensions.clear();
18068
18069         };
18070         private:
18071         e_RAB_ID_t      e_RAB_ID;
18072         drb_ID_t        drb_ID;
18073         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
18074         resource_configuration_t        resource_configuration;
18075         iE_Extensions_t iE_Extensions;
18076
18077 };
18078 /*
18079 E-RABs-ToBeAdded-SgNBAddReq-ItemIEs     X2AP-PROTOCOL-IES ::= {
18080         { ID id-E-RABs-ToBeAdded-SgNBAddReq-Item                CRITICALITY reject      TYPE E-RABs-ToBeAdded-SgNBAddReq-Item           PRESENCE mandatory},
18081         ...
18082 }
18083 */
18084
18085 struct E_RABs_ToBeAdded_SgNBAddReq_ItemIEs
18086 {
18087         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
18088         {
18089                 size_t get_index() const {return type;}
18090                 bool is_unknown() const { return type == 2; }
18091                 void clear() {type = 0;}
18092                 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(id_E_RABs_ToBeAdded_SgNBAddReq_Item); type=1;}
18093                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
18094                 template<typename V>  bool decode(V& v)
18095                 {
18096                         clear();
18097                         if(!v(ref_nested())) return false;
18098                         if(equal(id_E_RABs_ToBeAdded_SgNBAddReq_Item)) { type = 1; return true; }
18099                         else { type = 2; return true;}
18100                         return false;
18101
18102                 }
18103                 template<typename V> bool encode(V& v) const
18104                 {
18105                         return v(ref_nested());
18106
18107                 }
18108                 protected:
18109                 template<typename V>  bool decode(size_t index, V& v)
18110                 {
18111                         clear();
18112                         switch(index)
18113                         {
18114                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBAddReq_Item);} return false;
18115                         case 2: type = 2; return v(ref_nested());
18116                         ref_nested().clear();
18117                         }
18118                         return false;
18119
18120                 }
18121                 template<typename V> bool encode(size_t index, V& v) const
18122                 {
18123                         if(index != type) {return false;} return v(ref_nested());
18124
18125                 }
18126                 private:
18127                 size_t type {0};
18128
18129         };
18130         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
18131         {
18132                 size_t get_index() const {return type;}
18133                 bool is_unknown() const { return type == 2; }
18134                 void clear() {type = 0;}
18135                 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(reject); type=1;}
18136                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
18137                 template<typename V>  bool decode(V& v)
18138                 {
18139                         clear();
18140                         if(!v(ref_nested())) return false;
18141                         if(equal(reject)) { type = 1; return true; }
18142                         else { type = 2; return true;}
18143                         return false;
18144
18145                 }
18146                 template<typename V> bool encode(V& v) const
18147                 {
18148                         return v(ref_nested());
18149
18150                 }
18151                 protected:
18152                 template<typename V>  bool decode(size_t index, V& v)
18153                 {
18154                         clear();
18155                         switch(index)
18156                         {
18157                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
18158                         case 2: type = 2; return v(ref_nested());
18159                         ref_nested().clear();
18160                         }
18161                         return false;
18162
18163                 }
18164                 template<typename V> bool encode(size_t index, V& v) const
18165                 {
18166                         if(index != type) {return false;} return v(ref_nested());
18167
18168                 }
18169                 private:
18170                 size_t type {0};
18171
18172         };
18173         struct Value_t : asn::typefield<true>
18174         {
18175                 ~Value_t()      {clear();}
18176                 size_t get_index() const {return type;}
18177                 E_RABs_ToBeAdded_SgNBAddReq_Item& select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { return set<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
18178                 E_RABs_ToBeAdded_SgNBAddReq_Item const* get_id_E_RABs_ToBeAdded_SgNBAddReq_Item() const { return get<E_RABs_ToBeAdded_SgNBAddReq_Item>(1); }
18179                 bool is_unknown() const { return type == 2; }
18180                 void clear()
18181                 {
18182                         switch(type)
18183                         {
18184                         case 1: var.destroy<E_RABs_ToBeAdded_SgNBAddReq_Item>(); break;
18185                         }
18186                         type = 0; ref_nested().clear();
18187                 }
18188                 template<typename V> static inline void enumerate(V& v)
18189                 {
18190                         v.template operator()<E_RABs_ToBeAdded_SgNBAddReq_Item>(1);
18191
18192                 }
18193                 protected:
18194                 template<typename V> bool decode(size_t index, V& v)
18195                 {
18196                         clear();
18197                         switch(index)
18198                         {
18199                         case 1: v(select_id_E_RABs_ToBeAdded_SgNBAddReq_Item()); return true;
18200                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
18201                         }
18202                         return false;
18203
18204                 }
18205                 template<typename V> bool encode(size_t index, V& v) const
18206                 {
18207                         if(index != type) return false;
18208                         switch(type)
18209                         {
18210                         case 1: v(var.as<E_RABs_ToBeAdded_SgNBAddReq_Item>()); return true;
18211                         }
18212                         return false;
18213
18214                 }
18215                 private:
18216                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18217                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18218                 union union_type
18219                 {
18220                         char dummy1[sizeof(E_RABs_ToBeAdded_SgNBAddReq_Item)];
18221
18222                 };
18223                 asn::variant<sizeof(union_type)> var;
18224                 size_t type {0};
18225
18226         };
18227         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
18228         {
18229                 size_t get_index() const {return type;}
18230                 bool is_unknown() const { return type == 2; }
18231                 void clear() {type = 0;}
18232                 void select_id_E_RABs_ToBeAdded_SgNBAddReq_Item() { set(mandatory); type=1;}
18233                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
18234                 template<typename V>  bool decode(V& v)
18235                 {
18236                         clear();
18237                         if(!v(ref_nested())) return false;
18238                         if(equal(mandatory)) { type = 1; return true; }
18239                         else { type = 2; return true;}
18240                         return false;
18241
18242                 }
18243                 template<typename V> bool encode(V& v) const
18244                 {
18245                         return v(ref_nested());
18246
18247                 }
18248                 protected:
18249                 template<typename V>  bool decode(size_t index, V& v)
18250                 {
18251                         clear();
18252                         switch(index)
18253                         {
18254                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
18255                         case 2: type = 2; return v(ref_nested());
18256                         ref_nested().clear();
18257                         }
18258                         return false;
18259
18260                 }
18261                 template<typename V> bool encode(size_t index, V& v) const
18262                 {
18263                         if(index != type) {return false;} return v(ref_nested());
18264
18265                 }
18266                 private:
18267                 size_t type {0};
18268
18269         };
18270
18271 };
18272 /*
18273 E-RABs-ToBeAdded-SgNBAddReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBAddReq-ItemIEs} }
18274 */
18275
18276 struct E_RABs_ToBeAdded_SgNBAddReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>
18277 {
18278         static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBAddReqList_elm";}
18279         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBAddReq_ItemIEs>;
18280
18281 };
18282 struct E_RABs_ToBeAdded_SgNBAddReqList : asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>
18283 {
18284         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBAddReqList";}
18285         using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBAddReqList_elm>;
18286         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
18287
18288 };
18289 /*
18290 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18291         { ID id-RLCMode-transferred                                     CRITICALITY ignore      EXTENSION RLCMode                                       PRESENCE optional},
18292         ...
18293 }
18294 */
18295
18296 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs
18297 {
18298         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18299         {
18300                 size_t get_index() const {return type;}
18301                 bool is_unknown() const { return type == 2; }
18302                 void clear() {type = 0;}
18303                 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
18304                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18305                 template<typename V>  bool decode(V& v)
18306                 {
18307                         clear();
18308                         if(!v(ref_nested())) return false;
18309                         if(equal(id_RLCMode_transferred)) { type = 1; return true; }
18310                         else { type = 2; return true;}
18311                         return false;
18312
18313                 }
18314                 template<typename V> bool encode(V& v) const
18315                 {
18316                         return v(ref_nested());
18317
18318                 }
18319                 protected:
18320                 template<typename V>  bool decode(size_t index, V& v)
18321                 {
18322                         clear();
18323                         switch(index)
18324                         {
18325                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
18326                         case 2: type = 2; return v(ref_nested());
18327                         ref_nested().clear();
18328                         }
18329                         return false;
18330
18331                 }
18332                 template<typename V> bool encode(size_t index, V& v) const
18333                 {
18334                         if(index != type) {return false;} return v(ref_nested());
18335
18336                 }
18337                 private:
18338                 size_t type {0};
18339
18340         };
18341         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18342         {
18343                 size_t get_index() const {return type;}
18344                 bool is_unknown() const { return type == 2; }
18345                 void clear() {type = 0;}
18346                 void select_id_RLCMode_transferred() { set(ignore); type=1;}
18347                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18348                 template<typename V>  bool decode(V& v)
18349                 {
18350                         clear();
18351                         if(!v(ref_nested())) return false;
18352                         if(equal(ignore)) { type = 1; return true; }
18353                         else { type = 2; return true;}
18354                         return false;
18355
18356                 }
18357                 template<typename V> bool encode(V& v) const
18358                 {
18359                         return v(ref_nested());
18360
18361                 }
18362                 protected:
18363                 template<typename V>  bool decode(size_t index, V& v)
18364                 {
18365                         clear();
18366                         switch(index)
18367                         {
18368                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
18369                         case 2: type = 2; return v(ref_nested());
18370                         ref_nested().clear();
18371                         }
18372                         return false;
18373
18374                 }
18375                 template<typename V> bool encode(size_t index, V& v) const
18376                 {
18377                         if(index != type) {return false;} return v(ref_nested());
18378
18379                 }
18380                 private:
18381                 size_t type {0};
18382
18383         };
18384         struct Extension_t : asn::typefield<true>
18385         {
18386                 ~Extension_t()  {clear();}
18387                 size_t get_index() const {return type;}
18388                 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
18389                 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
18390                 bool is_unknown() const { return type == 2; }
18391                 void clear()
18392                 {
18393                         switch(type)
18394                         {
18395                         case 1: var.destroy<RLCMode>(); break;
18396                         }
18397                         type = 0; ref_nested().clear();
18398                 }
18399                 template<typename V> static inline void enumerate(V& v)
18400                 {
18401                         v.template operator()<RLCMode>(1);
18402
18403                 }
18404                 protected:
18405                 template<typename V> bool decode(size_t index, V& v)
18406                 {
18407                         clear();
18408                         switch(index)
18409                         {
18410                         case 1: v(select_id_RLCMode_transferred()); return true;
18411                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
18412                         }
18413                         return false;
18414
18415                 }
18416                 template<typename V> bool encode(size_t index, V& v) const
18417                 {
18418                         if(index != type) return false;
18419                         switch(type)
18420                         {
18421                         case 1: v(var.as<RLCMode>()); return true;
18422                         }
18423                         return false;
18424
18425                 }
18426                 private:
18427                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18428                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18429                 union union_type
18430                 {
18431                         char dummy1[sizeof(RLCMode)];
18432
18433                 };
18434                 asn::variant<sizeof(union_type)> var;
18435                 size_t type {0};
18436
18437         };
18438         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18439         {
18440                 size_t get_index() const {return type;}
18441                 bool is_unknown() const { return type == 2; }
18442                 void clear() {type = 0;}
18443                 void select_id_RLCMode_transferred() { set(optional); type=1;}
18444                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18445                 template<typename V>  bool decode(V& v)
18446                 {
18447                         clear();
18448                         if(!v(ref_nested())) return false;
18449                         if(equal(optional)) { type = 1; return true; }
18450                         else { type = 2; return true;}
18451                         return false;
18452
18453                 }
18454                 template<typename V> bool encode(V& v) const
18455                 {
18456                         return v(ref_nested());
18457
18458                 }
18459                 protected:
18460                 template<typename V>  bool decode(size_t index, V& v)
18461                 {
18462                         clear();
18463                         switch(index)
18464                         {
18465                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
18466                         case 2: type = 2; return v(ref_nested());
18467                         ref_nested().clear();
18468                         }
18469                         return false;
18470
18471                 }
18472                 template<typename V> bool encode(size_t index, V& v) const
18473                 {
18474                         if(index != type) {return false;} return v(ref_nested());
18475
18476                 }
18477                 private:
18478                 size_t type {0};
18479
18480         };
18481
18482 };
18483 /*
18484 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
18485         full-E-RAB-Level-QoS-Parameters                 E-RAB-Level-QoS-Parameters,
18486         max-MN-admit-E-RAB-Level-QoS-Parameters GBR-QosInformation                                                                                                                      OPTIONAL,
18487 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” and GBR QoS Information IE is present in Full E-RAB Level QoS Parameters IE --
18488         dL-Forwarding                                                   DL-Forwarding                                                                                                                                           OPTIONAL,
18489         meNB-DL-GTP-TEIDatMCG                                   GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
18490 -- This IE shall be present if MCG resource IE in the the EN-DC Resource Configuration IE is set to “present” --
18491         s1-UL-GTPtunnelEndpoint                                 GTPtunnelEndpoint,
18492         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresentExtIEs} }         OPTIONAL,
18493         ...
18494 }
18495 */
18496
18497 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<6, 0, true, 4>
18498 {
18499         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent";}
18500         using parent_t = asn::sequence<6, 0, true, 4>;
18501         struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
18502         {
18503                 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
18504                 using parent_t = E_RAB_Level_QoS_Parameters;
18505
18506         };
18507         full_E_RAB_Level_QoS_Parameters_t& ref_full_E_RAB_Level_QoS_Parameters() {return full_E_RAB_Level_QoS_Parameters;}
18508         full_E_RAB_Level_QoS_Parameters_t const& ref_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters;}
18509         struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
18510         {
18511                 static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
18512                 using parent_t = GBR_QosInformation;
18513                 static constexpr bool optional = true;
18514
18515         };
18516         max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
18517         max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
18518         struct dL_Forwarding_t : DL_Forwarding
18519         {
18520                 static constexpr const char* name() {return "dL_Forwarding_t";}
18521                 using parent_t = DL_Forwarding;
18522                 static constexpr bool optional = true;
18523
18524         };
18525         dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
18526         dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
18527         struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
18528         {
18529                 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
18530                 using parent_t = GTPtunnelEndpoint;
18531                 static constexpr bool optional = true;
18532
18533         };
18534         meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
18535         meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
18536         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
18537         {
18538                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
18539                 using parent_t = GTPtunnelEndpoint;
18540
18541         };
18542         s1_UL_GTPtunnelEndpoint_t& ref_s1_UL_GTPtunnelEndpoint() {return s1_UL_GTPtunnelEndpoint;}
18543         s1_UL_GTPtunnelEndpoint_t const& ref_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint;}
18544         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
18545         {
18546                 static constexpr const char* name() {return "iE_Extensions_t";}
18547                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
18548                 static constexpr bool optional = true;
18549
18550         };
18551         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18552         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18553         template<typename V> void decode(V& v)
18554         {
18555                 v(full_E_RAB_Level_QoS_Parameters);
18556                 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
18557                 v(dL_Forwarding);
18558                 v(meNB_DL_GTP_TEIDatMCG);
18559                 v(s1_UL_GTPtunnelEndpoint);
18560                 v(iE_Extensions);
18561
18562         };
18563         template<typename V> void encode(V& v) const
18564         {
18565                 v(full_E_RAB_Level_QoS_Parameters);
18566                 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
18567                 v(dL_Forwarding);
18568                 v(meNB_DL_GTP_TEIDatMCG);
18569                 v(s1_UL_GTPtunnelEndpoint);
18570                 v(iE_Extensions);
18571
18572         };
18573         void clear()
18574         {
18575                 full_E_RAB_Level_QoS_Parameters.clear();
18576                 max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
18577                 dL_Forwarding.clear();
18578                 meNB_DL_GTP_TEIDatMCG.clear();
18579                 s1_UL_GTPtunnelEndpoint.clear();
18580                 iE_Extensions.clear();
18581
18582         };
18583         private:
18584         full_E_RAB_Level_QoS_Parameters_t       full_E_RAB_Level_QoS_Parameters;
18585         max_MN_admit_E_RAB_Level_QoS_Parameters_t       max_MN_admit_E_RAB_Level_QoS_Parameters;
18586         dL_Forwarding_t dL_Forwarding;
18587         meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
18588         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
18589         iE_Extensions_t iE_Extensions;
18590
18591 };
18592 /*
18593 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18594         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
18595         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
18596         { ID id-duplicationActivation                                   CRITICALITY ignore      EXTENSION DuplicationActivation PRESENCE optional},
18597         ...
18598 }
18599 */
18600
18601 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
18602 {
18603         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18604         {
18605                 size_t get_index() const {return type;}
18606                 bool is_unknown() const { return type == 4; }
18607                 void clear() {type = 0;}
18608                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
18609                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
18610                 void select_id_duplicationActivation() { set(id_duplicationActivation); type=3;}
18611                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18612                 template<typename V>  bool decode(V& v)
18613                 {
18614                         clear();
18615                         if(!v(ref_nested())) return false;
18616                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
18617                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
18618                         else if(equal(id_duplicationActivation)) { type = 3; return true; }
18619                         else { type = 4; return true;}
18620                         return false;
18621
18622                 }
18623                 template<typename V> bool encode(V& v) const
18624                 {
18625                         return v(ref_nested());
18626
18627                 }
18628                 protected:
18629                 template<typename V>  bool decode(size_t index, V& v)
18630                 {
18631                         clear();
18632                         switch(index)
18633                         {
18634                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
18635                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
18636                         case 3: type = 3; if(v(ref_nested())) { return equal(id_duplicationActivation);} return false;
18637                         case 4: type = 4; return v(ref_nested());
18638                         ref_nested().clear();
18639                         }
18640                         return false;
18641
18642                 }
18643                 template<typename V> bool encode(size_t index, V& v) const
18644                 {
18645                         if(index != type) {return false;} return v(ref_nested());
18646
18647                 }
18648                 private:
18649                 size_t type {0};
18650
18651         };
18652         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18653         {
18654                 size_t get_index() const {return type;}
18655                 bool is_unknown() const { return type == 4; }
18656                 void clear() {type = 0;}
18657                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
18658                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
18659                 void select_id_duplicationActivation() { set(ignore); type=3;}
18660                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18661                 template<typename V>  bool decode(V& v)
18662                 {
18663                         clear();
18664                         if(!v(ref_nested())) return false;
18665                         if(equal(ignore)) { type = 1; return true; }
18666                         else if(equal(ignore)) { type = 2; return true; }
18667                         else if(equal(ignore)) { type = 3; return true; }
18668                         else { type = 4; return true;}
18669                         return false;
18670
18671                 }
18672                 template<typename V> bool encode(V& v) const
18673                 {
18674                         return v(ref_nested());
18675
18676                 }
18677                 protected:
18678                 template<typename V>  bool decode(size_t index, V& v)
18679                 {
18680                         clear();
18681                         switch(index)
18682                         {
18683                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
18684                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
18685                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
18686                         case 4: type = 4; return v(ref_nested());
18687                         ref_nested().clear();
18688                         }
18689                         return false;
18690
18691                 }
18692                 template<typename V> bool encode(size_t index, V& v) const
18693                 {
18694                         if(index != type) {return false;} return v(ref_nested());
18695
18696                 }
18697                 private:
18698                 size_t type {0};
18699
18700         };
18701         struct Extension_t : asn::typefield<true>
18702         {
18703                 ~Extension_t()  {clear();}
18704                 size_t get_index() const {return type;}
18705                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
18706                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
18707                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
18708                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
18709                 DuplicationActivation& select_id_duplicationActivation() { return set<DuplicationActivation>(3); }
18710                 DuplicationActivation const* get_id_duplicationActivation() const { return get<DuplicationActivation>(3); }
18711                 bool is_unknown() const { return type == 4; }
18712                 void clear()
18713                 {
18714                         switch(type)
18715                         {
18716                         case 1: var.destroy<PDCPSnLength>(); break;
18717                         case 2: var.destroy<PDCPSnLength>(); break;
18718                         case 3: var.destroy<DuplicationActivation>(); break;
18719                         }
18720                         type = 0; ref_nested().clear();
18721                 }
18722                 template<typename V> static inline void enumerate(V& v)
18723                 {
18724                         v.template operator()<PDCPSnLength>(1);
18725                         v.template operator()<PDCPSnLength>(2);
18726                         v.template operator()<DuplicationActivation>(3);
18727
18728                 }
18729                 protected:
18730                 template<typename V> bool decode(size_t index, V& v)
18731                 {
18732                         clear();
18733                         switch(index)
18734                         {
18735                         case 1: v(select_id_uLpDCPSnLength()); return true;
18736                         case 2: v(select_id_dLPDCPSnLength()); return true;
18737                         case 3: v(select_id_duplicationActivation()); return true;
18738                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
18739                         }
18740                         return false;
18741
18742                 }
18743                 template<typename V> bool encode(size_t index, V& v) const
18744                 {
18745                         if(index != type) return false;
18746                         switch(type)
18747                         {
18748                         case 1: v(var.as<PDCPSnLength>()); return true;
18749                         case 2: v(var.as<PDCPSnLength>()); return true;
18750                         case 3: v(var.as<DuplicationActivation>()); return true;
18751                         }
18752                         return false;
18753
18754                 }
18755                 private:
18756                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
18757                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
18758                 union union_type
18759                 {
18760                         char dummy1[sizeof(DuplicationActivation)];
18761                         char dummy2[sizeof(PDCPSnLength)];
18762
18763                 };
18764                 asn::variant<sizeof(union_type)> var;
18765                 size_t type {0};
18766
18767         };
18768         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18769         {
18770                 size_t get_index() const {return type;}
18771                 bool is_unknown() const { return type == 4; }
18772                 void clear() {type = 0;}
18773                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
18774                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
18775                 void select_id_duplicationActivation() { set(optional); type=3;}
18776                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18777                 template<typename V>  bool decode(V& v)
18778                 {
18779                         clear();
18780                         if(!v(ref_nested())) return false;
18781                         if(equal(optional)) { type = 1; return true; }
18782                         else if(equal(optional)) { type = 2; return true; }
18783                         else if(equal(optional)) { type = 3; return true; }
18784                         else { type = 4; return true;}
18785                         return false;
18786
18787                 }
18788                 template<typename V> bool encode(V& v) const
18789                 {
18790                         return v(ref_nested());
18791
18792                 }
18793                 protected:
18794                 template<typename V>  bool decode(size_t index, V& v)
18795                 {
18796                         clear();
18797                         switch(index)
18798                         {
18799                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
18800                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
18801                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
18802                         case 4: type = 4; return v(ref_nested());
18803                         ref_nested().clear();
18804                         }
18805                         return false;
18806
18807                 }
18808                 template<typename V> bool encode(size_t index, V& v) const
18809                 {
18810                         if(index != type) {return false;} return v(ref_nested());
18811
18812                 }
18813                 private:
18814                 size_t type {0};
18815
18816         };
18817
18818 };
18819 /*
18820 E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
18821         requested-SCG-E-RAB-Level-QoS-Parameters                E-RAB-Level-QoS-Parameters,
18822         meNB-UL-GTP-TEIDatPDCP                                                  GTPtunnelEndpoint,
18823         secondary-meNB-UL-GTP-TEIDatPDCP                                GTPtunnelEndpoint               OPTIONAL,
18824         rlc-Mode                                                                                RLCMode,
18825         uL-Configuration                                                                ULConfiguration                                                                                                                         OPTIONAL,
18826 -- This IE shall be present if MCG resource and SCG resources IEs in the the EN-DC Resource Configuration IE are set to “present” --
18827         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} }              OPTIONAL,
18828         ...
18829 }
18830 */
18831
18832 struct E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<6, 0, true, 3>
18833 {
18834         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent";}
18835         using parent_t = asn::sequence<6, 0, true, 3>;
18836         struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
18837         {
18838                 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
18839                 using parent_t = E_RAB_Level_QoS_Parameters;
18840
18841         };
18842         requested_SCG_E_RAB_Level_QoS_Parameters_t& ref_requested_SCG_E_RAB_Level_QoS_Parameters() {return requested_SCG_E_RAB_Level_QoS_Parameters;}
18843         requested_SCG_E_RAB_Level_QoS_Parameters_t const& ref_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters;}
18844         struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
18845         {
18846                 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
18847                 using parent_t = GTPtunnelEndpoint;
18848
18849         };
18850         meNB_UL_GTP_TEIDatPDCP_t& ref_meNB_UL_GTP_TEIDatPDCP() {return meNB_UL_GTP_TEIDatPDCP;}
18851         meNB_UL_GTP_TEIDatPDCP_t const& ref_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP;}
18852         struct secondary_meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
18853         {
18854                 static constexpr const char* name() {return "secondary_meNB_UL_GTP_TEIDatPDCP_t";}
18855                 using parent_t = GTPtunnelEndpoint;
18856                 static constexpr bool optional = true;
18857
18858         };
18859         secondary_meNB_UL_GTP_TEIDatPDCP_t& set_secondary_meNB_UL_GTP_TEIDatPDCP() { secondary_meNB_UL_GTP_TEIDatPDCP.setpresent(true); return secondary_meNB_UL_GTP_TEIDatPDCP;}
18860         secondary_meNB_UL_GTP_TEIDatPDCP_t const* get_secondary_meNB_UL_GTP_TEIDatPDCP() const {return secondary_meNB_UL_GTP_TEIDatPDCP.is_valid() ? &secondary_meNB_UL_GTP_TEIDatPDCP : nullptr;}
18861         struct rlc_Mode_t : RLCMode
18862         {
18863                 static constexpr const char* name() {return "rlc_Mode_t";}
18864                 using parent_t = RLCMode;
18865
18866         };
18867         rlc_Mode_t& ref_rlc_Mode() {return rlc_Mode;}
18868         rlc_Mode_t const& ref_rlc_Mode() const {return rlc_Mode;}
18869         struct uL_Configuration_t : ULConfiguration
18870         {
18871                 static constexpr const char* name() {return "uL_Configuration_t";}
18872                 using parent_t = ULConfiguration;
18873                 static constexpr bool optional = true;
18874
18875         };
18876         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
18877         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
18878         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
18879         {
18880                 static constexpr const char* name() {return "iE_Extensions_t";}
18881                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
18882                 static constexpr bool optional = true;
18883
18884         };
18885         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18886         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18887         template<typename V> void decode(V& v)
18888         {
18889                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
18890                 v(meNB_UL_GTP_TEIDatPDCP);
18891                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
18892                 v(rlc_Mode);
18893                 v(uL_Configuration);
18894                 v(iE_Extensions);
18895
18896         };
18897         template<typename V> void encode(V& v) const
18898         {
18899                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
18900                 v(meNB_UL_GTP_TEIDatPDCP);
18901                 v(secondary_meNB_UL_GTP_TEIDatPDCP);
18902                 v(rlc_Mode);
18903                 v(uL_Configuration);
18904                 v(iE_Extensions);
18905
18906         };
18907         void clear()
18908         {
18909                 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
18910                 meNB_UL_GTP_TEIDatPDCP.clear();
18911                 secondary_meNB_UL_GTP_TEIDatPDCP.clear();
18912                 rlc_Mode.clear();
18913                 uL_Configuration.clear();
18914                 iE_Extensions.clear();
18915
18916         };
18917         private:
18918         requested_SCG_E_RAB_Level_QoS_Parameters_t      requested_SCG_E_RAB_Level_QoS_Parameters;
18919         meNB_UL_GTP_TEIDatPDCP_t        meNB_UL_GTP_TEIDatPDCP;
18920         secondary_meNB_UL_GTP_TEIDatPDCP_t      secondary_meNB_UL_GTP_TEIDatPDCP;
18921         rlc_Mode_t      rlc_Mode;
18922         uL_Configuration_t      uL_Configuration;
18923         iE_Extensions_t iE_Extensions;
18924
18925 };
18926 /*
18927 E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18928         ...
18929 }
18930 */
18931
18932 struct E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs
18933 {
18934         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18935         {
18936                 size_t get_index() const {return type;}
18937                 bool is_unknown() const { return type == 1; }
18938                 void clear() {type = 0;}
18939                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18940                 template<typename V>  bool decode(V& v)
18941                 {
18942                         clear();
18943                         if(!v(ref_nested())) return false;
18944                         { type = 1; return true;}
18945                         return false;
18946
18947                 }
18948                 template<typename V> bool encode(V& v) const
18949                 {
18950                         return v(ref_nested());
18951
18952                 }
18953                 protected:
18954                 template<typename V>  bool decode(size_t index, V& v)
18955                 {
18956                         clear();
18957                         switch(index)
18958                         {
18959                         case 1: type = 1; return v(ref_nested());
18960                         ref_nested().clear();
18961                         }
18962                         return false;
18963
18964                 }
18965                 template<typename V> bool encode(size_t index, V& v) const
18966                 {
18967                         if(index != type) {return false;} return v(ref_nested());
18968
18969                 }
18970                 private:
18971                 size_t type {0};
18972
18973         };
18974         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18975         {
18976                 size_t get_index() const {return type;}
18977                 bool is_unknown() const { return type == 1; }
18978                 void clear() {type = 0;}
18979                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18980                 template<typename V>  bool decode(V& v)
18981                 {
18982                         clear();
18983                         if(!v(ref_nested())) return false;
18984                         { type = 1; return true;}
18985                         return false;
18986
18987                 }
18988                 template<typename V> bool encode(V& v) const
18989                 {
18990                         return v(ref_nested());
18991
18992                 }
18993                 protected:
18994                 template<typename V>  bool decode(size_t index, V& v)
18995                 {
18996                         clear();
18997                         switch(index)
18998                         {
18999                         case 1: type = 1; return v(ref_nested());
19000                         ref_nested().clear();
19001                         }
19002                         return false;
19003
19004                 }
19005                 template<typename V> bool encode(size_t index, V& v) const
19006                 {
19007                         if(index != type) {return false;} return v(ref_nested());
19008
19009                 }
19010                 private:
19011                 size_t type {0};
19012
19013         };
19014         struct Extension_t : asn::typefield<true>
19015         {
19016                 ~Extension_t()  {clear();}
19017                 size_t get_index() const {return type;}
19018                 bool is_unknown() const { return type == 1; }
19019                 void clear()
19020                 {
19021                         type = 0; ref_nested().clear();
19022                 }
19023                 template<typename V> static inline void enumerate(V& v)
19024                 {
19025
19026                 }
19027                 protected:
19028                 template<typename V> bool decode(size_t index, V& v)
19029                 {
19030                         clear();
19031                         switch(index)
19032                         {
19033                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19034                         }
19035                         return false;
19036
19037                 }
19038                 template<typename V> bool encode(size_t index, V& v) const
19039                 {
19040                         if(index != type) return false;
19041                         return false;
19042
19043                 }
19044                 private:
19045                 size_t type {0};
19046
19047         };
19048         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19049         {
19050                 size_t get_index() const {return type;}
19051                 bool is_unknown() const { return type == 1; }
19052                 void clear() {type = 0;}
19053                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19054                 template<typename V>  bool decode(V& v)
19055                 {
19056                         clear();
19057                         if(!v(ref_nested())) return false;
19058                         { type = 1; return true;}
19059                         return false;
19060
19061                 }
19062                 template<typename V> bool encode(V& v) const
19063                 {
19064                         return v(ref_nested());
19065
19066                 }
19067                 protected:
19068                 template<typename V>  bool decode(size_t index, V& v)
19069                 {
19070                         clear();
19071                         switch(index)
19072                         {
19073                         case 1: type = 1; return v(ref_nested());
19074                         ref_nested().clear();
19075                         }
19076                         return false;
19077
19078                 }
19079                 template<typename V> bool encode(size_t index, V& v) const
19080                 {
19081                         if(index != type) {return false;} return v(ref_nested());
19082
19083                 }
19084                 private:
19085                 size_t type {0};
19086
19087         };
19088
19089 };
19090 /*
19091 E-RABs-ToBeAdded-SgNBModReq-Item ::= SEQUENCE {
19092         e-RAB-ID                                                                E-RAB-ID,
19093         drb-ID                                                                  DRB-ID,
19094         en-DC-ResourceConfiguration                             EN-DC-ResourceConfiguration,
19095         resource-configuration                                  CHOICE {
19096                 sgNBPDCPpresent                                         E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPpresent,
19097                 sgNBPDCPnotpresent                                      E-RABs-ToBeAdded-SgNBModReq-Item-SgNBPDCPnotpresent,
19098                 ...
19099         },
19100         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeAdded-SgNBModReq-ItemExtIEs} } OPTIONAL,
19101         ...
19102 }
19103 */
19104
19105 struct E_RABs_ToBeAdded_SgNBModReq_Item : asn::sequence<5, 0, true, 1>
19106 {
19107         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-Item";}
19108         using parent_t = asn::sequence<5, 0, true, 1>;
19109         struct e_RAB_ID_t : E_RAB_ID
19110         {
19111                 static constexpr const char* name() {return "e_RAB_ID_t";}
19112                 using parent_t = E_RAB_ID;
19113
19114         };
19115         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19116         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19117         struct drb_ID_t : DRB_ID
19118         {
19119                 static constexpr const char* name() {return "drb_ID_t";}
19120                 using parent_t = DRB_ID;
19121
19122         };
19123         drb_ID_t& ref_drb_ID() {return drb_ID;}
19124         drb_ID_t const& ref_drb_ID() const {return drb_ID;}
19125         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
19126         {
19127                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
19128                 using parent_t = EN_DC_ResourceConfiguration;
19129
19130         };
19131         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
19132         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
19133         struct resource_configuration_t : asn::choice<2, 0, true>
19134         {
19135                 static constexpr const char* name() {return "resource_configuration_t";}
19136                 using parent_t = asn::choice<2, 0, true>;
19137                 index_type get_index() const {return index;}
19138                 bool is_unknown() const {return index == 3;}
19139                 void set_unknown() { set_index(3);  }
19140                 ~resource_configuration_t() {clear();}
19141                 struct sgNBPDCPpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent
19142                 {
19143                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
19144                         using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPpresent;
19145
19146                 };
19147                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent
19148                 {
19149                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
19150                         using parent_t = E_RABs_ToBeAdded_SgNBModReq_Item_SgNBPDCPnotpresent;
19151
19152                 };
19153                 void clear()
19154                 {
19155                         switch(get_index())
19156                         {
19157                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
19158                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
19159                         }
19160                         index = 0;
19161                         base::clear();
19162                 }
19163                 template<typename V> bool decode(size_t idx, V& v)
19164                 {
19165                         clear();
19166                         switch(idx)
19167                         {
19168                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
19169                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
19170                         }
19171                         return false;
19172
19173                 }
19174                 template<typename V> bool encode(V& v) const
19175                 {
19176                         switch(get_index())
19177                         {
19178                         case 1: return v(var.as<sgNBPDCPpresent_t>());
19179                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
19180                         }
19181                         return false;
19182                 }
19183                 template<typename V> static inline void enumerate(V& v)
19184                 {
19185                         v.template operator()<sgNBPDCPpresent_t>(1);
19186                         v.template operator()<sgNBPDCPnotpresent_t>(2);
19187
19188                 }
19189                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
19190                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
19191                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
19192                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
19193                 private:
19194                 void set_index(index_type i) {index = i; base::set();}
19195                 union union_type
19196                 {
19197                         char dummy1[sizeof(sgNBPDCPpresent_t)];
19198                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
19199
19200                 };
19201                 asn::variant<sizeof(union_type)>        var;
19202                 index_type      index {0};
19203         };
19204         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
19205         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
19206         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>
19207         {
19208                 static constexpr const char* name() {return "iE_Extensions_t";}
19209                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeAdded_SgNBModReq_ItemExtIEs>;
19210                 static constexpr bool optional = true;
19211
19212         };
19213         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19214         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19215         template<typename V> void decode(V& v)
19216         {
19217                 v(e_RAB_ID);
19218                 v(drb_ID);
19219                 v(en_DC_ResourceConfiguration);
19220                 v(resource_configuration);
19221                 v(iE_Extensions);
19222
19223         };
19224         template<typename V> void encode(V& v) const
19225         {
19226                 v(e_RAB_ID);
19227                 v(drb_ID);
19228                 v(en_DC_ResourceConfiguration);
19229                 v(resource_configuration);
19230                 v(iE_Extensions);
19231
19232         };
19233         void clear()
19234         {
19235                 e_RAB_ID.clear();
19236                 drb_ID.clear();
19237                 en_DC_ResourceConfiguration.clear();
19238                 resource_configuration.clear();
19239                 iE_Extensions.clear();
19240
19241         };
19242         private:
19243         e_RAB_ID_t      e_RAB_ID;
19244         drb_ID_t        drb_ID;
19245         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
19246         resource_configuration_t        resource_configuration;
19247         iE_Extensions_t iE_Extensions;
19248
19249 };
19250 /*
19251 E-RABs-ToBeAdded-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
19252         { ID id-E-RABs-ToBeAdded-SgNBModReq-Item                CRITICALITY ignore      TYPE E-RABs-ToBeAdded-SgNBModReq-Item           PRESENCE mandatory},
19253         ...
19254 }
19255 */
19256
19257 struct E_RABs_ToBeAdded_SgNBModReq_ItemIEs
19258 {
19259         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
19260         {
19261                 size_t get_index() const {return type;}
19262                 bool is_unknown() const { return type == 2; }
19263                 void clear() {type = 0;}
19264                 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(id_E_RABs_ToBeAdded_SgNBModReq_Item); type=1;}
19265                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
19266                 template<typename V>  bool decode(V& v)
19267                 {
19268                         clear();
19269                         if(!v(ref_nested())) return false;
19270                         if(equal(id_E_RABs_ToBeAdded_SgNBModReq_Item)) { type = 1; return true; }
19271                         else { type = 2; return true;}
19272                         return false;
19273
19274                 }
19275                 template<typename V> bool encode(V& v) const
19276                 {
19277                         return v(ref_nested());
19278
19279                 }
19280                 protected:
19281                 template<typename V>  bool decode(size_t index, V& v)
19282                 {
19283                         clear();
19284                         switch(index)
19285                         {
19286                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBModReq_Item);} return false;
19287                         case 2: type = 2; return v(ref_nested());
19288                         ref_nested().clear();
19289                         }
19290                         return false;
19291
19292                 }
19293                 template<typename V> bool encode(size_t index, V& v) const
19294                 {
19295                         if(index != type) {return false;} return v(ref_nested());
19296
19297                 }
19298                 private:
19299                 size_t type {0};
19300
19301         };
19302         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
19303         {
19304                 size_t get_index() const {return type;}
19305                 bool is_unknown() const { return type == 2; }
19306                 void clear() {type = 0;}
19307                 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(ignore); type=1;}
19308                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
19309                 template<typename V>  bool decode(V& v)
19310                 {
19311                         clear();
19312                         if(!v(ref_nested())) return false;
19313                         if(equal(ignore)) { type = 1; return true; }
19314                         else { type = 2; return true;}
19315                         return false;
19316
19317                 }
19318                 template<typename V> bool encode(V& v) const
19319                 {
19320                         return v(ref_nested());
19321
19322                 }
19323                 protected:
19324                 template<typename V>  bool decode(size_t index, V& v)
19325                 {
19326                         clear();
19327                         switch(index)
19328                         {
19329                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
19330                         case 2: type = 2; return v(ref_nested());
19331                         ref_nested().clear();
19332                         }
19333                         return false;
19334
19335                 }
19336                 template<typename V> bool encode(size_t index, V& v) const
19337                 {
19338                         if(index != type) {return false;} return v(ref_nested());
19339
19340                 }
19341                 private:
19342                 size_t type {0};
19343
19344         };
19345         struct Value_t : asn::typefield<true>
19346         {
19347                 ~Value_t()      {clear();}
19348                 size_t get_index() const {return type;}
19349                 E_RABs_ToBeAdded_SgNBModReq_Item& select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { return set<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
19350                 E_RABs_ToBeAdded_SgNBModReq_Item const* get_id_E_RABs_ToBeAdded_SgNBModReq_Item() const { return get<E_RABs_ToBeAdded_SgNBModReq_Item>(1); }
19351                 bool is_unknown() const { return type == 2; }
19352                 void clear()
19353                 {
19354                         switch(type)
19355                         {
19356                         case 1: var.destroy<E_RABs_ToBeAdded_SgNBModReq_Item>(); break;
19357                         }
19358                         type = 0; ref_nested().clear();
19359                 }
19360                 template<typename V> static inline void enumerate(V& v)
19361                 {
19362                         v.template operator()<E_RABs_ToBeAdded_SgNBModReq_Item>(1);
19363
19364                 }
19365                 protected:
19366                 template<typename V> bool decode(size_t index, V& v)
19367                 {
19368                         clear();
19369                         switch(index)
19370                         {
19371                         case 1: v(select_id_E_RABs_ToBeAdded_SgNBModReq_Item()); return true;
19372                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
19373                         }
19374                         return false;
19375
19376                 }
19377                 template<typename V> bool encode(size_t index, V& v) const
19378                 {
19379                         if(index != type) return false;
19380                         switch(type)
19381                         {
19382                         case 1: v(var.as<E_RABs_ToBeAdded_SgNBModReq_Item>()); return true;
19383                         }
19384                         return false;
19385
19386                 }
19387                 private:
19388                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
19389                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
19390                 union union_type
19391                 {
19392                         char dummy1[sizeof(E_RABs_ToBeAdded_SgNBModReq_Item)];
19393
19394                 };
19395                 asn::variant<sizeof(union_type)> var;
19396                 size_t type {0};
19397
19398         };
19399         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
19400         {
19401                 size_t get_index() const {return type;}
19402                 bool is_unknown() const { return type == 2; }
19403                 void clear() {type = 0;}
19404                 void select_id_E_RABs_ToBeAdded_SgNBModReq_Item() { set(mandatory); type=1;}
19405                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
19406                 template<typename V>  bool decode(V& v)
19407                 {
19408                         clear();
19409                         if(!v(ref_nested())) return false;
19410                         if(equal(mandatory)) { type = 1; return true; }
19411                         else { type = 2; return true;}
19412                         return false;
19413
19414                 }
19415                 template<typename V> bool encode(V& v) const
19416                 {
19417                         return v(ref_nested());
19418
19419                 }
19420                 protected:
19421                 template<typename V>  bool decode(size_t index, V& v)
19422                 {
19423                         clear();
19424                         switch(index)
19425                         {
19426                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
19427                         case 2: type = 2; return v(ref_nested());
19428                         ref_nested().clear();
19429                         }
19430                         return false;
19431
19432                 }
19433                 template<typename V> bool encode(size_t index, V& v) const
19434                 {
19435                         if(index != type) {return false;} return v(ref_nested());
19436
19437                 }
19438                 private:
19439                 size_t type {0};
19440
19441         };
19442
19443 };
19444 /*
19445 E-RABs-ToBeAdded-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeAdded-SgNBModReq-ItemIEs} }
19446 */
19447
19448 struct E_RABs_ToBeAdded_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>
19449 {
19450         static constexpr const char* name() {return "E_RABs_ToBeAdded_SgNBModReq_List_elm";}
19451         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeAdded_SgNBModReq_ItemIEs>;
19452
19453 };
19454 struct E_RABs_ToBeAdded_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>
19455 {
19456         static constexpr const char* name() {return "E-RABs-ToBeAdded-SgNBModReq-List";}
19457         using parent_t = asn::sequenceof<E_RABs_ToBeAdded_SgNBModReq_List_elm>;
19458         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
19459
19460 };
19461 /*
19462 E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19463         ...
19464 }
19465 */
19466
19467 struct E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs
19468 {
19469         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19470         {
19471                 size_t get_index() const {return type;}
19472                 bool is_unknown() const { return type == 1; }
19473                 void clear() {type = 0;}
19474                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19475                 template<typename V>  bool decode(V& v)
19476                 {
19477                         clear();
19478                         if(!v(ref_nested())) return false;
19479                         { type = 1; return true;}
19480                         return false;
19481
19482                 }
19483                 template<typename V> bool encode(V& v) const
19484                 {
19485                         return v(ref_nested());
19486
19487                 }
19488                 protected:
19489                 template<typename V>  bool decode(size_t index, V& v)
19490                 {
19491                         clear();
19492                         switch(index)
19493                         {
19494                         case 1: type = 1; return v(ref_nested());
19495                         ref_nested().clear();
19496                         }
19497                         return false;
19498
19499                 }
19500                 template<typename V> bool encode(size_t index, V& v) const
19501                 {
19502                         if(index != type) {return false;} return v(ref_nested());
19503
19504                 }
19505                 private:
19506                 size_t type {0};
19507
19508         };
19509         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19510         {
19511                 size_t get_index() const {return type;}
19512                 bool is_unknown() const { return type == 1; }
19513                 void clear() {type = 0;}
19514                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19515                 template<typename V>  bool decode(V& v)
19516                 {
19517                         clear();
19518                         if(!v(ref_nested())) return false;
19519                         { type = 1; return true;}
19520                         return false;
19521
19522                 }
19523                 template<typename V> bool encode(V& v) const
19524                 {
19525                         return v(ref_nested());
19526
19527                 }
19528                 protected:
19529                 template<typename V>  bool decode(size_t index, V& v)
19530                 {
19531                         clear();
19532                         switch(index)
19533                         {
19534                         case 1: type = 1; return v(ref_nested());
19535                         ref_nested().clear();
19536                         }
19537                         return false;
19538
19539                 }
19540                 template<typename V> bool encode(size_t index, V& v) const
19541                 {
19542                         if(index != type) {return false;} return v(ref_nested());
19543
19544                 }
19545                 private:
19546                 size_t type {0};
19547
19548         };
19549         struct Extension_t : asn::typefield<true>
19550         {
19551                 ~Extension_t()  {clear();}
19552                 size_t get_index() const {return type;}
19553                 bool is_unknown() const { return type == 1; }
19554                 void clear()
19555                 {
19556                         type = 0; ref_nested().clear();
19557                 }
19558                 template<typename V> static inline void enumerate(V& v)
19559                 {
19560
19561                 }
19562                 protected:
19563                 template<typename V> bool decode(size_t index, V& v)
19564                 {
19565                         clear();
19566                         switch(index)
19567                         {
19568                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19569                         }
19570                         return false;
19571
19572                 }
19573                 template<typename V> bool encode(size_t index, V& v) const
19574                 {
19575                         if(index != type) return false;
19576                         return false;
19577
19578                 }
19579                 private:
19580                 size_t type {0};
19581
19582         };
19583         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19584         {
19585                 size_t get_index() const {return type;}
19586                 bool is_unknown() const { return type == 1; }
19587                 void clear() {type = 0;}
19588                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19589                 template<typename V>  bool decode(V& v)
19590                 {
19591                         clear();
19592                         if(!v(ref_nested())) return false;
19593                         { type = 1; return true;}
19594                         return false;
19595
19596                 }
19597                 template<typename V> bool encode(V& v) const
19598                 {
19599                         return v(ref_nested());
19600
19601                 }
19602                 protected:
19603                 template<typename V>  bool decode(size_t index, V& v)
19604                 {
19605                         clear();
19606                         switch(index)
19607                         {
19608                         case 1: type = 1; return v(ref_nested());
19609                         ref_nested().clear();
19610                         }
19611                         return false;
19612
19613                 }
19614                 template<typename V> bool encode(size_t index, V& v) const
19615                 {
19616                         if(index != type) {return false;} return v(ref_nested());
19617
19618                 }
19619                 private:
19620                 size_t type {0};
19621
19622         };
19623
19624 };
19625 /*
19626 E-RABs-ToBeModified-ModReqItem-SCG-Bearer ::= SEQUENCE {
19627         e-RAB-ID                                                E-RAB-ID,
19628         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters                                                                                                              OPTIONAL,
19629         s1-UL-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                                               OPTIONAL,
19630         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
19631         ...
19632 }
19633 */
19634
19635 struct E_RABs_ToBeModified_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
19636 {
19637         static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-SCG-Bearer";}
19638         using parent_t = asn::sequence<4, 0, true, 3>;
19639         struct e_RAB_ID_t : E_RAB_ID
19640         {
19641                 static constexpr const char* name() {return "e_RAB_ID_t";}
19642                 using parent_t = E_RAB_ID;
19643
19644         };
19645         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19646         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19647         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
19648         {
19649                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
19650                 using parent_t = E_RAB_Level_QoS_Parameters;
19651                 static constexpr bool optional = true;
19652
19653         };
19654         e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
19655         e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
19656         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
19657         {
19658                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
19659                 using parent_t = GTPtunnelEndpoint;
19660                 static constexpr bool optional = true;
19661
19662         };
19663         s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
19664         s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
19665         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>
19666         {
19667                 static constexpr const char* name() {return "iE_Extensions_t";}
19668                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_SCG_BearerExtIEs>;
19669                 static constexpr bool optional = true;
19670
19671         };
19672         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19673         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19674         template<typename V> void decode(V& v)
19675         {
19676                 v(e_RAB_ID);
19677                 v(e_RAB_Level_QoS_Parameters);
19678                 v(s1_UL_GTPtunnelEndpoint);
19679                 v(iE_Extensions);
19680
19681         };
19682         template<typename V> void encode(V& v) const
19683         {
19684                 v(e_RAB_ID);
19685                 v(e_RAB_Level_QoS_Parameters);
19686                 v(s1_UL_GTPtunnelEndpoint);
19687                 v(iE_Extensions);
19688
19689         };
19690         void clear()
19691         {
19692                 e_RAB_ID.clear();
19693                 e_RAB_Level_QoS_Parameters.clear();
19694                 s1_UL_GTPtunnelEndpoint.clear();
19695                 iE_Extensions.clear();
19696
19697         };
19698         private:
19699         e_RAB_ID_t      e_RAB_ID;
19700         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
19701         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
19702         iE_Extensions_t iE_Extensions;
19703
19704 };
19705 /*
19706 E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19707         ...
19708 }
19709 */
19710
19711 struct E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs
19712 {
19713         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19714         {
19715                 size_t get_index() const {return type;}
19716                 bool is_unknown() const { return type == 1; }
19717                 void clear() {type = 0;}
19718                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19719                 template<typename V>  bool decode(V& v)
19720                 {
19721                         clear();
19722                         if(!v(ref_nested())) return false;
19723                         { type = 1; return true;}
19724                         return false;
19725
19726                 }
19727                 template<typename V> bool encode(V& v) const
19728                 {
19729                         return v(ref_nested());
19730
19731                 }
19732                 protected:
19733                 template<typename V>  bool decode(size_t index, V& v)
19734                 {
19735                         clear();
19736                         switch(index)
19737                         {
19738                         case 1: type = 1; return v(ref_nested());
19739                         ref_nested().clear();
19740                         }
19741                         return false;
19742
19743                 }
19744                 template<typename V> bool encode(size_t index, V& v) const
19745                 {
19746                         if(index != type) {return false;} return v(ref_nested());
19747
19748                 }
19749                 private:
19750                 size_t type {0};
19751
19752         };
19753         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19754         {
19755                 size_t get_index() const {return type;}
19756                 bool is_unknown() const { return type == 1; }
19757                 void clear() {type = 0;}
19758                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19759                 template<typename V>  bool decode(V& v)
19760                 {
19761                         clear();
19762                         if(!v(ref_nested())) return false;
19763                         { type = 1; return true;}
19764                         return false;
19765
19766                 }
19767                 template<typename V> bool encode(V& v) const
19768                 {
19769                         return v(ref_nested());
19770
19771                 }
19772                 protected:
19773                 template<typename V>  bool decode(size_t index, V& v)
19774                 {
19775                         clear();
19776                         switch(index)
19777                         {
19778                         case 1: type = 1; return v(ref_nested());
19779                         ref_nested().clear();
19780                         }
19781                         return false;
19782
19783                 }
19784                 template<typename V> bool encode(size_t index, V& v) const
19785                 {
19786                         if(index != type) {return false;} return v(ref_nested());
19787
19788                 }
19789                 private:
19790                 size_t type {0};
19791
19792         };
19793         struct Extension_t : asn::typefield<true>
19794         {
19795                 ~Extension_t()  {clear();}
19796                 size_t get_index() const {return type;}
19797                 bool is_unknown() const { return type == 1; }
19798                 void clear()
19799                 {
19800                         type = 0; ref_nested().clear();
19801                 }
19802                 template<typename V> static inline void enumerate(V& v)
19803                 {
19804
19805                 }
19806                 protected:
19807                 template<typename V> bool decode(size_t index, V& v)
19808                 {
19809                         clear();
19810                         switch(index)
19811                         {
19812                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19813                         }
19814                         return false;
19815
19816                 }
19817                 template<typename V> bool encode(size_t index, V& v) const
19818                 {
19819                         if(index != type) return false;
19820                         return false;
19821
19822                 }
19823                 private:
19824                 size_t type {0};
19825
19826         };
19827         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19828         {
19829                 size_t get_index() const {return type;}
19830                 bool is_unknown() const { return type == 1; }
19831                 void clear() {type = 0;}
19832                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19833                 template<typename V>  bool decode(V& v)
19834                 {
19835                         clear();
19836                         if(!v(ref_nested())) return false;
19837                         { type = 1; return true;}
19838                         return false;
19839
19840                 }
19841                 template<typename V> bool encode(V& v) const
19842                 {
19843                         return v(ref_nested());
19844
19845                 }
19846                 protected:
19847                 template<typename V>  bool decode(size_t index, V& v)
19848                 {
19849                         clear();
19850                         switch(index)
19851                         {
19852                         case 1: type = 1; return v(ref_nested());
19853                         ref_nested().clear();
19854                         }
19855                         return false;
19856
19857                 }
19858                 template<typename V> bool encode(size_t index, V& v) const
19859                 {
19860                         if(index != type) {return false;} return v(ref_nested());
19861
19862                 }
19863                 private:
19864                 size_t type {0};
19865
19866         };
19867
19868 };
19869 /*
19870 E-RABs-ToBeModified-ModReqItem-Split-Bearer ::= SEQUENCE {
19871         e-RAB-ID                                                E-RAB-ID,
19872         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters                                                                                                                              OPTIONAL,
19873         meNB-GTPtunnelEndpoint                  GTPtunnelEndpoint                                                                                                                                               OPTIONAL,
19874         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
19875         ...
19876 }
19877 */
19878
19879 struct E_RABs_ToBeModified_ModReqItem_Split_Bearer : asn::sequence<4, 0, true, 3>
19880 {
19881         static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem-Split-Bearer";}
19882         using parent_t = asn::sequence<4, 0, true, 3>;
19883         struct e_RAB_ID_t : E_RAB_ID
19884         {
19885                 static constexpr const char* name() {return "e_RAB_ID_t";}
19886                 using parent_t = E_RAB_ID;
19887
19888         };
19889         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
19890         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
19891         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
19892         {
19893                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
19894                 using parent_t = E_RAB_Level_QoS_Parameters;
19895                 static constexpr bool optional = true;
19896
19897         };
19898         e_RAB_Level_QoS_Parameters_t& set_e_RAB_Level_QoS_Parameters() { e_RAB_Level_QoS_Parameters.setpresent(true); return e_RAB_Level_QoS_Parameters;}
19899         e_RAB_Level_QoS_Parameters_t const* get_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters.is_valid() ? &e_RAB_Level_QoS_Parameters : nullptr;}
19900         struct meNB_GTPtunnelEndpoint_t : GTPtunnelEndpoint
19901         {
19902                 static constexpr const char* name() {return "meNB_GTPtunnelEndpoint_t";}
19903                 using parent_t = GTPtunnelEndpoint;
19904                 static constexpr bool optional = true;
19905
19906         };
19907         meNB_GTPtunnelEndpoint_t& set_meNB_GTPtunnelEndpoint() { meNB_GTPtunnelEndpoint.setpresent(true); return meNB_GTPtunnelEndpoint;}
19908         meNB_GTPtunnelEndpoint_t const* get_meNB_GTPtunnelEndpoint() const {return meNB_GTPtunnelEndpoint.is_valid() ? &meNB_GTPtunnelEndpoint : nullptr;}
19909         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>
19910         {
19911                 static constexpr const char* name() {return "iE_Extensions_t";}
19912                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_ModReqItem_Split_BearerExtIEs>;
19913                 static constexpr bool optional = true;
19914
19915         };
19916         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19917         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19918         template<typename V> void decode(V& v)
19919         {
19920                 v(e_RAB_ID);
19921                 v(e_RAB_Level_QoS_Parameters);
19922                 v(meNB_GTPtunnelEndpoint);
19923                 v(iE_Extensions);
19924
19925         };
19926         template<typename V> void encode(V& v) const
19927         {
19928                 v(e_RAB_ID);
19929                 v(e_RAB_Level_QoS_Parameters);
19930                 v(meNB_GTPtunnelEndpoint);
19931                 v(iE_Extensions);
19932
19933         };
19934         void clear()
19935         {
19936                 e_RAB_ID.clear();
19937                 e_RAB_Level_QoS_Parameters.clear();
19938                 meNB_GTPtunnelEndpoint.clear();
19939                 iE_Extensions.clear();
19940
19941         };
19942         private:
19943         e_RAB_ID_t      e_RAB_ID;
19944         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
19945         meNB_GTPtunnelEndpoint_t        meNB_GTPtunnelEndpoint;
19946         iE_Extensions_t iE_Extensions;
19947
19948 };
19949 /*
19950 E-RABs-ToBeModified-ModReqItem ::= CHOICE {
19951         sCG-Bearer              E-RABs-ToBeModified-ModReqItem-SCG-Bearer,
19952         split-Bearer    E-RABs-ToBeModified-ModReqItem-Split-Bearer,
19953         ...
19954 }
19955 */
19956
19957 struct E_RABs_ToBeModified_ModReqItem : asn::choice<2, 0, true>
19958 {
19959         static constexpr const char* name() {return "E-RABs-ToBeModified-ModReqItem";}
19960         using parent_t = asn::choice<2, 0, true>;
19961         index_type get_index() const {return index;}
19962         bool is_unknown() const {return index == 3;}
19963         void set_unknown() { set_index(3);  }
19964         ~E_RABs_ToBeModified_ModReqItem() {clear();}
19965         struct sCG_Bearer_t : E_RABs_ToBeModified_ModReqItem_SCG_Bearer
19966         {
19967                 static constexpr const char* name() {return "sCG_Bearer_t";}
19968                 using parent_t = E_RABs_ToBeModified_ModReqItem_SCG_Bearer;
19969
19970         };
19971         struct split_Bearer_t : E_RABs_ToBeModified_ModReqItem_Split_Bearer
19972         {
19973                 static constexpr const char* name() {return "split_Bearer_t";}
19974                 using parent_t = E_RABs_ToBeModified_ModReqItem_Split_Bearer;
19975
19976         };
19977         void clear()
19978         {
19979                 switch(get_index())
19980                 {
19981                 case 1: var.destroy<sCG_Bearer_t>(); break;
19982                 case 2: var.destroy<split_Bearer_t>(); break;
19983                 }
19984                 index = 0;
19985                 base::clear();
19986         }
19987         template<typename V> bool decode(size_t idx, V& v)
19988         {
19989                 clear();
19990                 switch(idx)
19991                 {
19992                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
19993                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
19994                 }
19995                 return false;
19996
19997         }
19998         template<typename V> bool encode(V& v) const
19999         {
20000                 switch(get_index())
20001                 {
20002                 case 1: return v(var.as<sCG_Bearer_t>());
20003                 case 2: return v(var.as<split_Bearer_t>());
20004                 }
20005                 return false;
20006         }
20007         template<typename V> static inline void enumerate(V& v)
20008         {
20009                 v.template operator()<sCG_Bearer_t>(1);
20010                 v.template operator()<split_Bearer_t>(2);
20011
20012         }
20013         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
20014         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
20015         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
20016         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
20017         private:
20018         void set_index(index_type i) {index = i; base::set();}
20019         union union_type
20020         {
20021                 char dummy1[sizeof(sCG_Bearer_t)];
20022                 char dummy2[sizeof(split_Bearer_t)];
20023
20024         };
20025         asn::variant<sizeof(union_type)>        var;
20026         index_type      index {0};
20027 };
20028 /*
20029 E-RABs-ToBeModified-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
20030         { ID id-E-RABs-ToBeModified-ModReqItem  CRITICALITY ignore      TYPE E-RABs-ToBeModified-ModReqItem             PRESENCE mandatory},
20031         ...
20032 }
20033 */
20034
20035 struct E_RABs_ToBeModified_ModReqItemIEs
20036 {
20037         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
20038         {
20039                 size_t get_index() const {return type;}
20040                 bool is_unknown() const { return type == 2; }
20041                 void clear() {type = 0;}
20042                 void select_id_E_RABs_ToBeModified_ModReqItem() { set(id_E_RABs_ToBeModified_ModReqItem); type=1;}
20043                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
20044                 template<typename V>  bool decode(V& v)
20045                 {
20046                         clear();
20047                         if(!v(ref_nested())) return false;
20048                         if(equal(id_E_RABs_ToBeModified_ModReqItem)) { type = 1; return true; }
20049                         else { type = 2; return true;}
20050                         return false;
20051
20052                 }
20053                 template<typename V> bool encode(V& v) const
20054                 {
20055                         return v(ref_nested());
20056
20057                 }
20058                 protected:
20059                 template<typename V>  bool decode(size_t index, V& v)
20060                 {
20061                         clear();
20062                         switch(index)
20063                         {
20064                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_ModReqItem);} return false;
20065                         case 2: type = 2; return v(ref_nested());
20066                         ref_nested().clear();
20067                         }
20068                         return false;
20069
20070                 }
20071                 template<typename V> bool encode(size_t index, V& v) const
20072                 {
20073                         if(index != type) {return false;} return v(ref_nested());
20074
20075                 }
20076                 private:
20077                 size_t type {0};
20078
20079         };
20080         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
20081         {
20082                 size_t get_index() const {return type;}
20083                 bool is_unknown() const { return type == 2; }
20084                 void clear() {type = 0;}
20085                 void select_id_E_RABs_ToBeModified_ModReqItem() { set(ignore); type=1;}
20086                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
20087                 template<typename V>  bool decode(V& v)
20088                 {
20089                         clear();
20090                         if(!v(ref_nested())) return false;
20091                         if(equal(ignore)) { type = 1; return true; }
20092                         else { type = 2; return true;}
20093                         return false;
20094
20095                 }
20096                 template<typename V> bool encode(V& v) const
20097                 {
20098                         return v(ref_nested());
20099
20100                 }
20101                 protected:
20102                 template<typename V>  bool decode(size_t index, V& v)
20103                 {
20104                         clear();
20105                         switch(index)
20106                         {
20107                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20108                         case 2: type = 2; return v(ref_nested());
20109                         ref_nested().clear();
20110                         }
20111                         return false;
20112
20113                 }
20114                 template<typename V> bool encode(size_t index, V& v) const
20115                 {
20116                         if(index != type) {return false;} return v(ref_nested());
20117
20118                 }
20119                 private:
20120                 size_t type {0};
20121
20122         };
20123         struct Value_t : asn::typefield<true>
20124         {
20125                 ~Value_t()      {clear();}
20126                 size_t get_index() const {return type;}
20127                 E_RABs_ToBeModified_ModReqItem& select_id_E_RABs_ToBeModified_ModReqItem() { return set<E_RABs_ToBeModified_ModReqItem>(1); }
20128                 E_RABs_ToBeModified_ModReqItem const* get_id_E_RABs_ToBeModified_ModReqItem() const { return get<E_RABs_ToBeModified_ModReqItem>(1); }
20129                 bool is_unknown() const { return type == 2; }
20130                 void clear()
20131                 {
20132                         switch(type)
20133                         {
20134                         case 1: var.destroy<E_RABs_ToBeModified_ModReqItem>(); break;
20135                         }
20136                         type = 0; ref_nested().clear();
20137                 }
20138                 template<typename V> static inline void enumerate(V& v)
20139                 {
20140                         v.template operator()<E_RABs_ToBeModified_ModReqItem>(1);
20141
20142                 }
20143                 protected:
20144                 template<typename V> bool decode(size_t index, V& v)
20145                 {
20146                         clear();
20147                         switch(index)
20148                         {
20149                         case 1: v(select_id_E_RABs_ToBeModified_ModReqItem()); return true;
20150                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
20151                         }
20152                         return false;
20153
20154                 }
20155                 template<typename V> bool encode(size_t index, V& v) const
20156                 {
20157                         if(index != type) return false;
20158                         switch(type)
20159                         {
20160                         case 1: v(var.as<E_RABs_ToBeModified_ModReqItem>()); return true;
20161                         }
20162                         return false;
20163
20164                 }
20165                 private:
20166                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20167                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20168                 union union_type
20169                 {
20170                         char dummy1[sizeof(E_RABs_ToBeModified_ModReqItem)];
20171
20172                 };
20173                 asn::variant<sizeof(union_type)> var;
20174                 size_t type {0};
20175
20176         };
20177         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
20178         {
20179                 size_t get_index() const {return type;}
20180                 bool is_unknown() const { return type == 2; }
20181                 void clear() {type = 0;}
20182                 void select_id_E_RABs_ToBeModified_ModReqItem() { set(mandatory); type=1;}
20183                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
20184                 template<typename V>  bool decode(V& v)
20185                 {
20186                         clear();
20187                         if(!v(ref_nested())) return false;
20188                         if(equal(mandatory)) { type = 1; return true; }
20189                         else { type = 2; return true;}
20190                         return false;
20191
20192                 }
20193                 template<typename V> bool encode(V& v) const
20194                 {
20195                         return v(ref_nested());
20196
20197                 }
20198                 protected:
20199                 template<typename V>  bool decode(size_t index, V& v)
20200                 {
20201                         clear();
20202                         switch(index)
20203                         {
20204                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
20205                         case 2: type = 2; return v(ref_nested());
20206                         ref_nested().clear();
20207                         }
20208                         return false;
20209
20210                 }
20211                 template<typename V> bool encode(size_t index, V& v) const
20212                 {
20213                         if(index != type) {return false;} return v(ref_nested());
20214
20215                 }
20216                 private:
20217                 size_t type {0};
20218
20219         };
20220
20221 };
20222 /*
20223 E-RABs-ToBeModified-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-ModReqItemIEs} }
20224 */
20225
20226 struct E_RABs_ToBeModified_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>
20227 {
20228         static constexpr const char* name() {return "E_RABs_ToBeModified_List_ModReq_elm";}
20229         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_ModReqItemIEs>;
20230
20231 };
20232 struct E_RABs_ToBeModified_List_ModReq : asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>
20233 {
20234         static constexpr const char* name() {return "E-RABs-ToBeModified-List-ModReq";}
20235         using parent_t = asn::sequenceof<E_RABs_ToBeModified_List_ModReq_elm>;
20236         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
20237
20238 };
20239 /*
20240 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20241         { ID id-RLC-Status                      CRITICALITY ignore                      EXTENSION RLC-Status                            PRESENCE optional },
20242         ...
20243 }
20244 */
20245
20246 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs
20247 {
20248         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20249         {
20250                 size_t get_index() const {return type;}
20251                 bool is_unknown() const { return type == 2; }
20252                 void clear() {type = 0;}
20253                 void select_id_RLC_Status() { set(id_RLC_Status); type=1;}
20254                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20255                 template<typename V>  bool decode(V& v)
20256                 {
20257                         clear();
20258                         if(!v(ref_nested())) return false;
20259                         if(equal(id_RLC_Status)) { type = 1; return true; }
20260                         else { type = 2; return true;}
20261                         return false;
20262
20263                 }
20264                 template<typename V> bool encode(V& v) const
20265                 {
20266                         return v(ref_nested());
20267
20268                 }
20269                 protected:
20270                 template<typename V>  bool decode(size_t index, V& v)
20271                 {
20272                         clear();
20273                         switch(index)
20274                         {
20275                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
20276                         case 2: type = 2; return v(ref_nested());
20277                         ref_nested().clear();
20278                         }
20279                         return false;
20280
20281                 }
20282                 template<typename V> bool encode(size_t index, V& v) const
20283                 {
20284                         if(index != type) {return false;} return v(ref_nested());
20285
20286                 }
20287                 private:
20288                 size_t type {0};
20289
20290         };
20291         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20292         {
20293                 size_t get_index() const {return type;}
20294                 bool is_unknown() const { return type == 2; }
20295                 void clear() {type = 0;}
20296                 void select_id_RLC_Status() { set(ignore); type=1;}
20297                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20298                 template<typename V>  bool decode(V& v)
20299                 {
20300                         clear();
20301                         if(!v(ref_nested())) return false;
20302                         if(equal(ignore)) { type = 1; return true; }
20303                         else { type = 2; return true;}
20304                         return false;
20305
20306                 }
20307                 template<typename V> bool encode(V& v) const
20308                 {
20309                         return v(ref_nested());
20310
20311                 }
20312                 protected:
20313                 template<typename V>  bool decode(size_t index, V& v)
20314                 {
20315                         clear();
20316                         switch(index)
20317                         {
20318                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20319                         case 2: type = 2; return v(ref_nested());
20320                         ref_nested().clear();
20321                         }
20322                         return false;
20323
20324                 }
20325                 template<typename V> bool encode(size_t index, V& v) const
20326                 {
20327                         if(index != type) {return false;} return v(ref_nested());
20328
20329                 }
20330                 private:
20331                 size_t type {0};
20332
20333         };
20334         struct Extension_t : asn::typefield<true>
20335         {
20336                 ~Extension_t()  {clear();}
20337                 size_t get_index() const {return type;}
20338                 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
20339                 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
20340                 bool is_unknown() const { return type == 2; }
20341                 void clear()
20342                 {
20343                         switch(type)
20344                         {
20345                         case 1: var.destroy<RLC_Status>(); break;
20346                         }
20347                         type = 0; ref_nested().clear();
20348                 }
20349                 template<typename V> static inline void enumerate(V& v)
20350                 {
20351                         v.template operator()<RLC_Status>(1);
20352
20353                 }
20354                 protected:
20355                 template<typename V> bool decode(size_t index, V& v)
20356                 {
20357                         clear();
20358                         switch(index)
20359                         {
20360                         case 1: v(select_id_RLC_Status()); return true;
20361                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
20362                         }
20363                         return false;
20364
20365                 }
20366                 template<typename V> bool encode(size_t index, V& v) const
20367                 {
20368                         if(index != type) return false;
20369                         switch(type)
20370                         {
20371                         case 1: v(var.as<RLC_Status>()); return true;
20372                         }
20373                         return false;
20374
20375                 }
20376                 private:
20377                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20378                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20379                 union union_type
20380                 {
20381                         char dummy1[sizeof(RLC_Status)];
20382
20383                 };
20384                 asn::variant<sizeof(union_type)> var;
20385                 size_t type {0};
20386
20387         };
20388         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20389         {
20390                 size_t get_index() const {return type;}
20391                 bool is_unknown() const { return type == 2; }
20392                 void clear() {type = 0;}
20393                 void select_id_RLC_Status() { set(optional); type=1;}
20394                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20395                 template<typename V>  bool decode(V& v)
20396                 {
20397                         clear();
20398                         if(!v(ref_nested())) return false;
20399                         if(equal(optional)) { type = 1; return true; }
20400                         else { type = 2; return true;}
20401                         return false;
20402
20403                 }
20404                 template<typename V> bool encode(V& v) const
20405                 {
20406                         return v(ref_nested());
20407
20408                 }
20409                 protected:
20410                 template<typename V>  bool decode(size_t index, V& v)
20411                 {
20412                         clear();
20413                         switch(index)
20414                         {
20415                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20416                         case 2: type = 2; return v(ref_nested());
20417                         ref_nested().clear();
20418                         }
20419                         return false;
20420
20421                 }
20422                 template<typename V> bool encode(size_t index, V& v) const
20423                 {
20424                         if(index != type) {return false;} return v(ref_nested());
20425
20426                 }
20427                 private:
20428                 size_t type {0};
20429
20430         };
20431
20432 };
20433 /*
20434 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
20435         full-E-RAB-Level-QoS-Parameters                 E-RAB-Level-QoS-Parameters                                                                                                                                              OPTIONAL,
20436         max-MN-admit-E-RAB-Level-QoS-Parameters GBR-QosInformation                                                                                                                                              OPTIONAL,
20437         meNB-DL-GTP-TEIDatMCG                                   GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
20438         s1-UL-GTPtunnelEndpoint                                 GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
20439         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresentExtIEs} }      OPTIONAL,
20440         ...
20441 }
20442 */
20443
20444 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
20445 {
20446         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent";}
20447         using parent_t = asn::sequence<5, 0, true, 5>;
20448         struct full_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
20449         {
20450                 static constexpr const char* name() {return "full_E_RAB_Level_QoS_Parameters_t";}
20451                 using parent_t = E_RAB_Level_QoS_Parameters;
20452                 static constexpr bool optional = true;
20453
20454         };
20455         full_E_RAB_Level_QoS_Parameters_t& set_full_E_RAB_Level_QoS_Parameters() { full_E_RAB_Level_QoS_Parameters.setpresent(true); return full_E_RAB_Level_QoS_Parameters;}
20456         full_E_RAB_Level_QoS_Parameters_t const* get_full_E_RAB_Level_QoS_Parameters() const {return full_E_RAB_Level_QoS_Parameters.is_valid() ? &full_E_RAB_Level_QoS_Parameters : nullptr;}
20457         struct max_MN_admit_E_RAB_Level_QoS_Parameters_t : GBR_QosInformation
20458         {
20459                 static constexpr const char* name() {return "max_MN_admit_E_RAB_Level_QoS_Parameters_t";}
20460                 using parent_t = GBR_QosInformation;
20461                 static constexpr bool optional = true;
20462
20463         };
20464         max_MN_admit_E_RAB_Level_QoS_Parameters_t& set_max_MN_admit_E_RAB_Level_QoS_Parameters() { max_MN_admit_E_RAB_Level_QoS_Parameters.setpresent(true); return max_MN_admit_E_RAB_Level_QoS_Parameters;}
20465         max_MN_admit_E_RAB_Level_QoS_Parameters_t const* get_max_MN_admit_E_RAB_Level_QoS_Parameters() const {return max_MN_admit_E_RAB_Level_QoS_Parameters.is_valid() ? &max_MN_admit_E_RAB_Level_QoS_Parameters : nullptr;}
20466         struct meNB_DL_GTP_TEIDatMCG_t : GTPtunnelEndpoint
20467         {
20468                 static constexpr const char* name() {return "meNB_DL_GTP_TEIDatMCG_t";}
20469                 using parent_t = GTPtunnelEndpoint;
20470                 static constexpr bool optional = true;
20471
20472         };
20473         meNB_DL_GTP_TEIDatMCG_t& set_meNB_DL_GTP_TEIDatMCG() { meNB_DL_GTP_TEIDatMCG.setpresent(true); return meNB_DL_GTP_TEIDatMCG;}
20474         meNB_DL_GTP_TEIDatMCG_t const* get_meNB_DL_GTP_TEIDatMCG() const {return meNB_DL_GTP_TEIDatMCG.is_valid() ? &meNB_DL_GTP_TEIDatMCG : nullptr;}
20475         struct s1_UL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
20476         {
20477                 static constexpr const char* name() {return "s1_UL_GTPtunnelEndpoint_t";}
20478                 using parent_t = GTPtunnelEndpoint;
20479                 static constexpr bool optional = true;
20480
20481         };
20482         s1_UL_GTPtunnelEndpoint_t& set_s1_UL_GTPtunnelEndpoint() { s1_UL_GTPtunnelEndpoint.setpresent(true); return s1_UL_GTPtunnelEndpoint;}
20483         s1_UL_GTPtunnelEndpoint_t const* get_s1_UL_GTPtunnelEndpoint() const {return s1_UL_GTPtunnelEndpoint.is_valid() ? &s1_UL_GTPtunnelEndpoint : nullptr;}
20484         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
20485         {
20486                 static constexpr const char* name() {return "iE_Extensions_t";}
20487                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
20488                 static constexpr bool optional = true;
20489
20490         };
20491         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20492         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20493         template<typename V> void decode(V& v)
20494         {
20495                 v(full_E_RAB_Level_QoS_Parameters);
20496                 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
20497                 v(meNB_DL_GTP_TEIDatMCG);
20498                 v(s1_UL_GTPtunnelEndpoint);
20499                 v(iE_Extensions);
20500
20501         };
20502         template<typename V> void encode(V& v) const
20503         {
20504                 v(full_E_RAB_Level_QoS_Parameters);
20505                 v(max_MN_admit_E_RAB_Level_QoS_Parameters);
20506                 v(meNB_DL_GTP_TEIDatMCG);
20507                 v(s1_UL_GTPtunnelEndpoint);
20508                 v(iE_Extensions);
20509
20510         };
20511         void clear()
20512         {
20513                 full_E_RAB_Level_QoS_Parameters.clear();
20514                 max_MN_admit_E_RAB_Level_QoS_Parameters.clear();
20515                 meNB_DL_GTP_TEIDatMCG.clear();
20516                 s1_UL_GTPtunnelEndpoint.clear();
20517                 iE_Extensions.clear();
20518
20519         };
20520         private:
20521         full_E_RAB_Level_QoS_Parameters_t       full_E_RAB_Level_QoS_Parameters;
20522         max_MN_admit_E_RAB_Level_QoS_Parameters_t       max_MN_admit_E_RAB_Level_QoS_Parameters;
20523         meNB_DL_GTP_TEIDatMCG_t meNB_DL_GTP_TEIDatMCG;
20524         s1_UL_GTPtunnelEndpoint_t       s1_UL_GTPtunnelEndpoint;
20525         iE_Extensions_t iE_Extensions;
20526
20527 };
20528 /*
20529 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20530         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
20531         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
20532         { ID id-secondarymeNBULGTPTEIDatPDCP                            CRITICALITY ignore      EXTENSION GTPtunnelEndpoint                     PRESENCE optional},
20533         ...
20534 }
20535 */
20536
20537 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
20538 {
20539         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20540         {
20541                 size_t get_index() const {return type;}
20542                 bool is_unknown() const { return type == 4; }
20543                 void clear() {type = 0;}
20544                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
20545                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
20546                 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(id_secondarymeNBULGTPTEIDatPDCP); type=3;}
20547                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20548                 template<typename V>  bool decode(V& v)
20549                 {
20550                         clear();
20551                         if(!v(ref_nested())) return false;
20552                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
20553                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
20554                         else if(equal(id_secondarymeNBULGTPTEIDatPDCP)) { type = 3; return true; }
20555                         else { type = 4; return true;}
20556                         return false;
20557
20558                 }
20559                 template<typename V> bool encode(V& v) const
20560                 {
20561                         return v(ref_nested());
20562
20563                 }
20564                 protected:
20565                 template<typename V>  bool decode(size_t index, V& v)
20566                 {
20567                         clear();
20568                         switch(index)
20569                         {
20570                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
20571                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
20572                         case 3: type = 3; if(v(ref_nested())) { return equal(id_secondarymeNBULGTPTEIDatPDCP);} return false;
20573                         case 4: type = 4; return v(ref_nested());
20574                         ref_nested().clear();
20575                         }
20576                         return false;
20577
20578                 }
20579                 template<typename V> bool encode(size_t index, V& v) const
20580                 {
20581                         if(index != type) {return false;} return v(ref_nested());
20582
20583                 }
20584                 private:
20585                 size_t type {0};
20586
20587         };
20588         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20589         {
20590                 size_t get_index() const {return type;}
20591                 bool is_unknown() const { return type == 4; }
20592                 void clear() {type = 0;}
20593                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
20594                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
20595                 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(ignore); type=3;}
20596                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20597                 template<typename V>  bool decode(V& v)
20598                 {
20599                         clear();
20600                         if(!v(ref_nested())) return false;
20601                         if(equal(ignore)) { type = 1; return true; }
20602                         else if(equal(ignore)) { type = 2; return true; }
20603                         else if(equal(ignore)) { type = 3; return true; }
20604                         else { type = 4; return true;}
20605                         return false;
20606
20607                 }
20608                 template<typename V> bool encode(V& v) const
20609                 {
20610                         return v(ref_nested());
20611
20612                 }
20613                 protected:
20614                 template<typename V>  bool decode(size_t index, V& v)
20615                 {
20616                         clear();
20617                         switch(index)
20618                         {
20619                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20620                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
20621                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
20622                         case 4: type = 4; return v(ref_nested());
20623                         ref_nested().clear();
20624                         }
20625                         return false;
20626
20627                 }
20628                 template<typename V> bool encode(size_t index, V& v) const
20629                 {
20630                         if(index != type) {return false;} return v(ref_nested());
20631
20632                 }
20633                 private:
20634                 size_t type {0};
20635
20636         };
20637         struct Extension_t : asn::typefield<true>
20638         {
20639                 ~Extension_t()  {clear();}
20640                 size_t get_index() const {return type;}
20641                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
20642                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
20643                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
20644                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
20645                 GTPtunnelEndpoint& select_id_secondarymeNBULGTPTEIDatPDCP() { return set<GTPtunnelEndpoint>(3); }
20646                 GTPtunnelEndpoint const* get_id_secondarymeNBULGTPTEIDatPDCP() const { return get<GTPtunnelEndpoint>(3); }
20647                 bool is_unknown() const { return type == 4; }
20648                 void clear()
20649                 {
20650                         switch(type)
20651                         {
20652                         case 1: var.destroy<PDCPSnLength>(); break;
20653                         case 2: var.destroy<PDCPSnLength>(); break;
20654                         case 3: var.destroy<GTPtunnelEndpoint>(); break;
20655                         }
20656                         type = 0; ref_nested().clear();
20657                 }
20658                 template<typename V> static inline void enumerate(V& v)
20659                 {
20660                         v.template operator()<PDCPSnLength>(1);
20661                         v.template operator()<PDCPSnLength>(2);
20662                         v.template operator()<GTPtunnelEndpoint>(3);
20663
20664                 }
20665                 protected:
20666                 template<typename V> bool decode(size_t index, V& v)
20667                 {
20668                         clear();
20669                         switch(index)
20670                         {
20671                         case 1: v(select_id_uLpDCPSnLength()); return true;
20672                         case 2: v(select_id_dLPDCPSnLength()); return true;
20673                         case 3: v(select_id_secondarymeNBULGTPTEIDatPDCP()); return true;
20674                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
20675                         }
20676                         return false;
20677
20678                 }
20679                 template<typename V> bool encode(size_t index, V& v) const
20680                 {
20681                         if(index != type) return false;
20682                         switch(type)
20683                         {
20684                         case 1: v(var.as<PDCPSnLength>()); return true;
20685                         case 2: v(var.as<PDCPSnLength>()); return true;
20686                         case 3: v(var.as<GTPtunnelEndpoint>()); return true;
20687                         }
20688                         return false;
20689
20690                 }
20691                 private:
20692                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20693                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20694                 union union_type
20695                 {
20696                         char dummy1[sizeof(GTPtunnelEndpoint)];
20697                         char dummy2[sizeof(PDCPSnLength)];
20698
20699                 };
20700                 asn::variant<sizeof(union_type)> var;
20701                 size_t type {0};
20702
20703         };
20704         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20705         {
20706                 size_t get_index() const {return type;}
20707                 bool is_unknown() const { return type == 4; }
20708                 void clear() {type = 0;}
20709                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
20710                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
20711                 void select_id_secondarymeNBULGTPTEIDatPDCP() { set(optional); type=3;}
20712                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20713                 template<typename V>  bool decode(V& v)
20714                 {
20715                         clear();
20716                         if(!v(ref_nested())) return false;
20717                         if(equal(optional)) { type = 1; return true; }
20718                         else if(equal(optional)) { type = 2; return true; }
20719                         else if(equal(optional)) { type = 3; return true; }
20720                         else { type = 4; return true;}
20721                         return false;
20722
20723                 }
20724                 template<typename V> bool encode(V& v) const
20725                 {
20726                         return v(ref_nested());
20727
20728                 }
20729                 protected:
20730                 template<typename V>  bool decode(size_t index, V& v)
20731                 {
20732                         clear();
20733                         switch(index)
20734                         {
20735                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20736                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
20737                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
20738                         case 4: type = 4; return v(ref_nested());
20739                         ref_nested().clear();
20740                         }
20741                         return false;
20742
20743                 }
20744                 template<typename V> bool encode(size_t index, V& v) const
20745                 {
20746                         if(index != type) {return false;} return v(ref_nested());
20747
20748                 }
20749                 private:
20750                 size_t type {0};
20751
20752         };
20753
20754 };
20755 /*
20756 E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
20757         requested-SCG-E-RAB-Level-QoS-Parameters                E-RAB-Level-QoS-Parameters                                                                                                                                                      OPTIONAL,
20758         meNB-UL-GTP-TEIDatPDCP                                          GTPtunnelEndpoint                                                                                                                                                                       OPTIONAL,
20759         uL-Configuration                                                                ULConfiguration                                                                                                                                                                         OPTIONAL,
20760         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} }   OPTIONAL,
20761         ...
20762 }
20763 */
20764
20765 struct E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<4, 0, true, 4>
20766 {
20767         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent";}
20768         using parent_t = asn::sequence<4, 0, true, 4>;
20769         struct requested_SCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
20770         {
20771                 static constexpr const char* name() {return "requested_SCG_E_RAB_Level_QoS_Parameters_t";}
20772                 using parent_t = E_RAB_Level_QoS_Parameters;
20773                 static constexpr bool optional = true;
20774
20775         };
20776         requested_SCG_E_RAB_Level_QoS_Parameters_t& set_requested_SCG_E_RAB_Level_QoS_Parameters() { requested_SCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_SCG_E_RAB_Level_QoS_Parameters;}
20777         requested_SCG_E_RAB_Level_QoS_Parameters_t const* get_requested_SCG_E_RAB_Level_QoS_Parameters() const {return requested_SCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_SCG_E_RAB_Level_QoS_Parameters : nullptr;}
20778         struct meNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
20779         {
20780                 static constexpr const char* name() {return "meNB_UL_GTP_TEIDatPDCP_t";}
20781                 using parent_t = GTPtunnelEndpoint;
20782                 static constexpr bool optional = true;
20783
20784         };
20785         meNB_UL_GTP_TEIDatPDCP_t& set_meNB_UL_GTP_TEIDatPDCP() { meNB_UL_GTP_TEIDatPDCP.setpresent(true); return meNB_UL_GTP_TEIDatPDCP;}
20786         meNB_UL_GTP_TEIDatPDCP_t const* get_meNB_UL_GTP_TEIDatPDCP() const {return meNB_UL_GTP_TEIDatPDCP.is_valid() ? &meNB_UL_GTP_TEIDatPDCP : nullptr;}
20787         struct uL_Configuration_t : ULConfiguration
20788         {
20789                 static constexpr const char* name() {return "uL_Configuration_t";}
20790                 using parent_t = ULConfiguration;
20791                 static constexpr bool optional = true;
20792
20793         };
20794         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
20795         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
20796         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
20797         {
20798                 static constexpr const char* name() {return "iE_Extensions_t";}
20799                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
20800                 static constexpr bool optional = true;
20801
20802         };
20803         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20804         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20805         template<typename V> void decode(V& v)
20806         {
20807                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
20808                 v(meNB_UL_GTP_TEIDatPDCP);
20809                 v(uL_Configuration);
20810                 v(iE_Extensions);
20811
20812         };
20813         template<typename V> void encode(V& v) const
20814         {
20815                 v(requested_SCG_E_RAB_Level_QoS_Parameters);
20816                 v(meNB_UL_GTP_TEIDatPDCP);
20817                 v(uL_Configuration);
20818                 v(iE_Extensions);
20819
20820         };
20821         void clear()
20822         {
20823                 requested_SCG_E_RAB_Level_QoS_Parameters.clear();
20824                 meNB_UL_GTP_TEIDatPDCP.clear();
20825                 uL_Configuration.clear();
20826                 iE_Extensions.clear();
20827
20828         };
20829         private:
20830         requested_SCG_E_RAB_Level_QoS_Parameters_t      requested_SCG_E_RAB_Level_QoS_Parameters;
20831         meNB_UL_GTP_TEIDatPDCP_t        meNB_UL_GTP_TEIDatPDCP;
20832         uL_Configuration_t      uL_Configuration;
20833         iE_Extensions_t iE_Extensions;
20834
20835 };
20836 /*
20837 E-RABs-ToBeModified-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20838         ...
20839 }
20840 */
20841
20842 struct E_RABs_ToBeModified_SgNBModReq_ItemExtIEs
20843 {
20844         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20845         {
20846                 size_t get_index() const {return type;}
20847                 bool is_unknown() const { return type == 1; }
20848                 void clear() {type = 0;}
20849                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20850                 template<typename V>  bool decode(V& v)
20851                 {
20852                         clear();
20853                         if(!v(ref_nested())) return false;
20854                         { type = 1; return true;}
20855                         return false;
20856
20857                 }
20858                 template<typename V> bool encode(V& v) const
20859                 {
20860                         return v(ref_nested());
20861
20862                 }
20863                 protected:
20864                 template<typename V>  bool decode(size_t index, V& v)
20865                 {
20866                         clear();
20867                         switch(index)
20868                         {
20869                         case 1: type = 1; return v(ref_nested());
20870                         ref_nested().clear();
20871                         }
20872                         return false;
20873
20874                 }
20875                 template<typename V> bool encode(size_t index, V& v) const
20876                 {
20877                         if(index != type) {return false;} return v(ref_nested());
20878
20879                 }
20880                 private:
20881                 size_t type {0};
20882
20883         };
20884         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20885         {
20886                 size_t get_index() const {return type;}
20887                 bool is_unknown() const { return type == 1; }
20888                 void clear() {type = 0;}
20889                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20890                 template<typename V>  bool decode(V& v)
20891                 {
20892                         clear();
20893                         if(!v(ref_nested())) return false;
20894                         { type = 1; return true;}
20895                         return false;
20896
20897                 }
20898                 template<typename V> bool encode(V& v) const
20899                 {
20900                         return v(ref_nested());
20901
20902                 }
20903                 protected:
20904                 template<typename V>  bool decode(size_t index, V& v)
20905                 {
20906                         clear();
20907                         switch(index)
20908                         {
20909                         case 1: type = 1; return v(ref_nested());
20910                         ref_nested().clear();
20911                         }
20912                         return false;
20913
20914                 }
20915                 template<typename V> bool encode(size_t index, V& v) const
20916                 {
20917                         if(index != type) {return false;} return v(ref_nested());
20918
20919                 }
20920                 private:
20921                 size_t type {0};
20922
20923         };
20924         struct Extension_t : asn::typefield<true>
20925         {
20926                 ~Extension_t()  {clear();}
20927                 size_t get_index() const {return type;}
20928                 bool is_unknown() const { return type == 1; }
20929                 void clear()
20930                 {
20931                         type = 0; ref_nested().clear();
20932                 }
20933                 template<typename V> static inline void enumerate(V& v)
20934                 {
20935
20936                 }
20937                 protected:
20938                 template<typename V> bool decode(size_t index, V& v)
20939                 {
20940                         clear();
20941                         switch(index)
20942                         {
20943                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20944                         }
20945                         return false;
20946
20947                 }
20948                 template<typename V> bool encode(size_t index, V& v) const
20949                 {
20950                         if(index != type) return false;
20951                         return false;
20952
20953                 }
20954                 private:
20955                 size_t type {0};
20956
20957         };
20958         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20959         {
20960                 size_t get_index() const {return type;}
20961                 bool is_unknown() const { return type == 1; }
20962                 void clear() {type = 0;}
20963                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20964                 template<typename V>  bool decode(V& v)
20965                 {
20966                         clear();
20967                         if(!v(ref_nested())) return false;
20968                         { type = 1; return true;}
20969                         return false;
20970
20971                 }
20972                 template<typename V> bool encode(V& v) const
20973                 {
20974                         return v(ref_nested());
20975
20976                 }
20977                 protected:
20978                 template<typename V>  bool decode(size_t index, V& v)
20979                 {
20980                         clear();
20981                         switch(index)
20982                         {
20983                         case 1: type = 1; return v(ref_nested());
20984                         ref_nested().clear();
20985                         }
20986                         return false;
20987
20988                 }
20989                 template<typename V> bool encode(size_t index, V& v) const
20990                 {
20991                         if(index != type) {return false;} return v(ref_nested());
20992
20993                 }
20994                 private:
20995                 size_t type {0};
20996
20997         };
20998
20999 };
21000 /*
21001 E-RABs-ToBeModified-SgNBModReq-Item ::= SEQUENCE {
21002         e-RAB-ID                                                                E-RAB-ID,
21003         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
21004         resource-configuration                          CHOICE {
21005                 sgNBPDCPpresent                                         E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPpresent,
21006                 sgNBPDCPnotpresent                                      E-RABs-ToBeModified-SgNBModReq-Item-SgNBPDCPnotpresent,
21007                 ...
21008         },
21009         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReq-ItemExtIEs} }      OPTIONAL,
21010         ...
21011 }
21012 */
21013
21014 struct E_RABs_ToBeModified_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
21015 {
21016         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-Item";}
21017         using parent_t = asn::sequence<4, 0, true, 1>;
21018         struct e_RAB_ID_t : E_RAB_ID
21019         {
21020                 static constexpr const char* name() {return "e_RAB_ID_t";}
21021                 using parent_t = E_RAB_ID;
21022
21023         };
21024         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
21025         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
21026         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
21027         {
21028                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
21029                 using parent_t = EN_DC_ResourceConfiguration;
21030
21031         };
21032         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
21033         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
21034         struct resource_configuration_t : asn::choice<2, 0, true>
21035         {
21036                 static constexpr const char* name() {return "resource_configuration_t";}
21037                 using parent_t = asn::choice<2, 0, true>;
21038                 index_type get_index() const {return index;}
21039                 bool is_unknown() const {return index == 3;}
21040                 void set_unknown() { set_index(3);  }
21041                 ~resource_configuration_t() {clear();}
21042                 struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent
21043                 {
21044                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
21045                         using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPpresent;
21046
21047                 };
21048                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent
21049                 {
21050                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
21051                         using parent_t = E_RABs_ToBeModified_SgNBModReq_Item_SgNBPDCPnotpresent;
21052
21053                 };
21054                 void clear()
21055                 {
21056                         switch(get_index())
21057                         {
21058                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
21059                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
21060                         }
21061                         index = 0;
21062                         base::clear();
21063                 }
21064                 template<typename V> bool decode(size_t idx, V& v)
21065                 {
21066                         clear();
21067                         switch(idx)
21068                         {
21069                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
21070                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
21071                         }
21072                         return false;
21073
21074                 }
21075                 template<typename V> bool encode(V& v) const
21076                 {
21077                         switch(get_index())
21078                         {
21079                         case 1: return v(var.as<sgNBPDCPpresent_t>());
21080                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
21081                         }
21082                         return false;
21083                 }
21084                 template<typename V> static inline void enumerate(V& v)
21085                 {
21086                         v.template operator()<sgNBPDCPpresent_t>(1);
21087                         v.template operator()<sgNBPDCPnotpresent_t>(2);
21088
21089                 }
21090                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
21091                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
21092                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
21093                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
21094                 private:
21095                 void set_index(index_type i) {index = i; base::set();}
21096                 union union_type
21097                 {
21098                         char dummy1[sizeof(sgNBPDCPpresent_t)];
21099                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
21100
21101                 };
21102                 asn::variant<sizeof(union_type)>        var;
21103                 index_type      index {0};
21104         };
21105         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
21106         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
21107         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>
21108         {
21109                 static constexpr const char* name() {return "iE_Extensions_t";}
21110                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReq_ItemExtIEs>;
21111                 static constexpr bool optional = true;
21112
21113         };
21114         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21115         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21116         template<typename V> void decode(V& v)
21117         {
21118                 v(e_RAB_ID);
21119                 v(en_DC_ResourceConfiguration);
21120                 v(resource_configuration);
21121                 v(iE_Extensions);
21122
21123         };
21124         template<typename V> void encode(V& v) const
21125         {
21126                 v(e_RAB_ID);
21127                 v(en_DC_ResourceConfiguration);
21128                 v(resource_configuration);
21129                 v(iE_Extensions);
21130
21131         };
21132         void clear()
21133         {
21134                 e_RAB_ID.clear();
21135                 en_DC_ResourceConfiguration.clear();
21136                 resource_configuration.clear();
21137                 iE_Extensions.clear();
21138
21139         };
21140         private:
21141         e_RAB_ID_t      e_RAB_ID;
21142         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
21143         resource_configuration_t        resource_configuration;
21144         iE_Extensions_t iE_Extensions;
21145
21146 };
21147 /*
21148 E-RABs-ToBeModified-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
21149         { ID id-E-RABs-ToBeModified-SgNBModReq-Item     CRITICALITY ignore      TYPE E-RABs-ToBeModified-SgNBModReq-Item                PRESENCE mandatory},
21150         ...
21151 }
21152 */
21153
21154 struct E_RABs_ToBeModified_SgNBModReq_ItemIEs
21155 {
21156         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
21157         {
21158                 size_t get_index() const {return type;}
21159                 bool is_unknown() const { return type == 2; }
21160                 void clear() {type = 0;}
21161                 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(id_E_RABs_ToBeModified_SgNBModReq_Item); type=1;}
21162                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
21163                 template<typename V>  bool decode(V& v)
21164                 {
21165                         clear();
21166                         if(!v(ref_nested())) return false;
21167                         if(equal(id_E_RABs_ToBeModified_SgNBModReq_Item)) { type = 1; return true; }
21168                         else { type = 2; return true;}
21169                         return false;
21170
21171                 }
21172                 template<typename V> bool encode(V& v) const
21173                 {
21174                         return v(ref_nested());
21175
21176                 }
21177                 protected:
21178                 template<typename V>  bool decode(size_t index, V& v)
21179                 {
21180                         clear();
21181                         switch(index)
21182                         {
21183                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReq_Item);} return false;
21184                         case 2: type = 2; return v(ref_nested());
21185                         ref_nested().clear();
21186                         }
21187                         return false;
21188
21189                 }
21190                 template<typename V> bool encode(size_t index, V& v) const
21191                 {
21192                         if(index != type) {return false;} return v(ref_nested());
21193
21194                 }
21195                 private:
21196                 size_t type {0};
21197
21198         };
21199         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
21200         {
21201                 size_t get_index() const {return type;}
21202                 bool is_unknown() const { return type == 2; }
21203                 void clear() {type = 0;}
21204                 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(ignore); type=1;}
21205                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
21206                 template<typename V>  bool decode(V& v)
21207                 {
21208                         clear();
21209                         if(!v(ref_nested())) return false;
21210                         if(equal(ignore)) { type = 1; return true; }
21211                         else { type = 2; return true;}
21212                         return false;
21213
21214                 }
21215                 template<typename V> bool encode(V& v) const
21216                 {
21217                         return v(ref_nested());
21218
21219                 }
21220                 protected:
21221                 template<typename V>  bool decode(size_t index, V& v)
21222                 {
21223                         clear();
21224                         switch(index)
21225                         {
21226                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21227                         case 2: type = 2; return v(ref_nested());
21228                         ref_nested().clear();
21229                         }
21230                         return false;
21231
21232                 }
21233                 template<typename V> bool encode(size_t index, V& v) const
21234                 {
21235                         if(index != type) {return false;} return v(ref_nested());
21236
21237                 }
21238                 private:
21239                 size_t type {0};
21240
21241         };
21242         struct Value_t : asn::typefield<true>
21243         {
21244                 ~Value_t()      {clear();}
21245                 size_t get_index() const {return type;}
21246                 E_RABs_ToBeModified_SgNBModReq_Item& select_id_E_RABs_ToBeModified_SgNBModReq_Item() { return set<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
21247                 E_RABs_ToBeModified_SgNBModReq_Item const* get_id_E_RABs_ToBeModified_SgNBModReq_Item() const { return get<E_RABs_ToBeModified_SgNBModReq_Item>(1); }
21248                 bool is_unknown() const { return type == 2; }
21249                 void clear()
21250                 {
21251                         switch(type)
21252                         {
21253                         case 1: var.destroy<E_RABs_ToBeModified_SgNBModReq_Item>(); break;
21254                         }
21255                         type = 0; ref_nested().clear();
21256                 }
21257                 template<typename V> static inline void enumerate(V& v)
21258                 {
21259                         v.template operator()<E_RABs_ToBeModified_SgNBModReq_Item>(1);
21260
21261                 }
21262                 protected:
21263                 template<typename V> bool decode(size_t index, V& v)
21264                 {
21265                         clear();
21266                         switch(index)
21267                         {
21268                         case 1: v(select_id_E_RABs_ToBeModified_SgNBModReq_Item()); return true;
21269                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
21270                         }
21271                         return false;
21272
21273                 }
21274                 template<typename V> bool encode(size_t index, V& v) const
21275                 {
21276                         if(index != type) return false;
21277                         switch(type)
21278                         {
21279                         case 1: v(var.as<E_RABs_ToBeModified_SgNBModReq_Item>()); return true;
21280                         }
21281                         return false;
21282
21283                 }
21284                 private:
21285                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21286                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21287                 union union_type
21288                 {
21289                         char dummy1[sizeof(E_RABs_ToBeModified_SgNBModReq_Item)];
21290
21291                 };
21292                 asn::variant<sizeof(union_type)> var;
21293                 size_t type {0};
21294
21295         };
21296         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
21297         {
21298                 size_t get_index() const {return type;}
21299                 bool is_unknown() const { return type == 2; }
21300                 void clear() {type = 0;}
21301                 void select_id_E_RABs_ToBeModified_SgNBModReq_Item() { set(mandatory); type=1;}
21302                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
21303                 template<typename V>  bool decode(V& v)
21304                 {
21305                         clear();
21306                         if(!v(ref_nested())) return false;
21307                         if(equal(mandatory)) { type = 1; return true; }
21308                         else { type = 2; return true;}
21309                         return false;
21310
21311                 }
21312                 template<typename V> bool encode(V& v) const
21313                 {
21314                         return v(ref_nested());
21315
21316                 }
21317                 protected:
21318                 template<typename V>  bool decode(size_t index, V& v)
21319                 {
21320                         clear();
21321                         switch(index)
21322                         {
21323                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
21324                         case 2: type = 2; return v(ref_nested());
21325                         ref_nested().clear();
21326                         }
21327                         return false;
21328
21329                 }
21330                 template<typename V> bool encode(size_t index, V& v) const
21331                 {
21332                         if(index != type) {return false;} return v(ref_nested());
21333
21334                 }
21335                 private:
21336                 size_t type {0};
21337
21338         };
21339
21340 };
21341 /*
21342 E-RABs-ToBeModified-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReq-ItemIEs} }
21343 */
21344
21345 struct E_RABs_ToBeModified_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>
21346 {
21347         static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReq_List_elm";}
21348         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReq_ItemIEs>;
21349
21350 };
21351 struct E_RABs_ToBeModified_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>
21352 {
21353         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReq-List";}
21354         using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReq_List_elm>;
21355         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
21356
21357 };
21358 /*
21359 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21360         { ID id-uLpDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
21361         { ID id-dLPDCPSnLength                                                  CRITICALITY ignore      EXTENSION PDCPSnLength                                  PRESENCE optional}|
21362         { ID id-new-drb-ID-req                                                  CRITICALITY ignore      EXTENSION NewDRBIDrequest                               PRESENCE optional},
21363         ...
21364 }
21365 */
21366
21367 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs
21368 {
21369         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21370         {
21371                 size_t get_index() const {return type;}
21372                 bool is_unknown() const { return type == 4; }
21373                 void clear() {type = 0;}
21374                 void select_id_uLpDCPSnLength() { set(id_uLpDCPSnLength); type=1;}
21375                 void select_id_dLPDCPSnLength() { set(id_dLPDCPSnLength); type=2;}
21376                 void select_id_new_drb_ID_req() { set(id_new_drb_ID_req); type=3;}
21377                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21378                 template<typename V>  bool decode(V& v)
21379                 {
21380                         clear();
21381                         if(!v(ref_nested())) return false;
21382                         if(equal(id_uLpDCPSnLength)) { type = 1; return true; }
21383                         else if(equal(id_dLPDCPSnLength)) { type = 2; return true; }
21384                         else if(equal(id_new_drb_ID_req)) { type = 3; return true; }
21385                         else { type = 4; return true;}
21386                         return false;
21387
21388                 }
21389                 template<typename V> bool encode(V& v) const
21390                 {
21391                         return v(ref_nested());
21392
21393                 }
21394                 protected:
21395                 template<typename V>  bool decode(size_t index, V& v)
21396                 {
21397                         clear();
21398                         switch(index)
21399                         {
21400                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uLpDCPSnLength);} return false;
21401                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dLPDCPSnLength);} return false;
21402                         case 3: type = 3; if(v(ref_nested())) { return equal(id_new_drb_ID_req);} return false;
21403                         case 4: type = 4; return v(ref_nested());
21404                         ref_nested().clear();
21405                         }
21406                         return false;
21407
21408                 }
21409                 template<typename V> bool encode(size_t index, V& v) const
21410                 {
21411                         if(index != type) {return false;} return v(ref_nested());
21412
21413                 }
21414                 private:
21415                 size_t type {0};
21416
21417         };
21418         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21419         {
21420                 size_t get_index() const {return type;}
21421                 bool is_unknown() const { return type == 4; }
21422                 void clear() {type = 0;}
21423                 void select_id_uLpDCPSnLength() { set(ignore); type=1;}
21424                 void select_id_dLPDCPSnLength() { set(ignore); type=2;}
21425                 void select_id_new_drb_ID_req() { set(ignore); type=3;}
21426                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21427                 template<typename V>  bool decode(V& v)
21428                 {
21429                         clear();
21430                         if(!v(ref_nested())) return false;
21431                         if(equal(ignore)) { type = 1; return true; }
21432                         else if(equal(ignore)) { type = 2; return true; }
21433                         else if(equal(ignore)) { type = 3; return true; }
21434                         else { type = 4; return true;}
21435                         return false;
21436
21437                 }
21438                 template<typename V> bool encode(V& v) const
21439                 {
21440                         return v(ref_nested());
21441
21442                 }
21443                 protected:
21444                 template<typename V>  bool decode(size_t index, V& v)
21445                 {
21446                         clear();
21447                         switch(index)
21448                         {
21449                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21450                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21451                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
21452                         case 4: type = 4; return v(ref_nested());
21453                         ref_nested().clear();
21454                         }
21455                         return false;
21456
21457                 }
21458                 template<typename V> bool encode(size_t index, V& v) const
21459                 {
21460                         if(index != type) {return false;} return v(ref_nested());
21461
21462                 }
21463                 private:
21464                 size_t type {0};
21465
21466         };
21467         struct Extension_t : asn::typefield<true>
21468         {
21469                 ~Extension_t()  {clear();}
21470                 size_t get_index() const {return type;}
21471                 PDCPSnLength& select_id_uLpDCPSnLength() { return set<PDCPSnLength>(1); }
21472                 PDCPSnLength const* get_id_uLpDCPSnLength() const { return get<PDCPSnLength>(1); }
21473                 PDCPSnLength& select_id_dLPDCPSnLength() { return set<PDCPSnLength>(2); }
21474                 PDCPSnLength const* get_id_dLPDCPSnLength() const { return get<PDCPSnLength>(2); }
21475                 NewDRBIDrequest& select_id_new_drb_ID_req() { return set<NewDRBIDrequest>(3); }
21476                 NewDRBIDrequest const* get_id_new_drb_ID_req() const { return get<NewDRBIDrequest>(3); }
21477                 bool is_unknown() const { return type == 4; }
21478                 void clear()
21479                 {
21480                         switch(type)
21481                         {
21482                         case 1: var.destroy<PDCPSnLength>(); break;
21483                         case 2: var.destroy<PDCPSnLength>(); break;
21484                         case 3: var.destroy<NewDRBIDrequest>(); break;
21485                         }
21486                         type = 0; ref_nested().clear();
21487                 }
21488                 template<typename V> static inline void enumerate(V& v)
21489                 {
21490                         v.template operator()<PDCPSnLength>(1);
21491                         v.template operator()<PDCPSnLength>(2);
21492                         v.template operator()<NewDRBIDrequest>(3);
21493
21494                 }
21495                 protected:
21496                 template<typename V> bool decode(size_t index, V& v)
21497                 {
21498                         clear();
21499                         switch(index)
21500                         {
21501                         case 1: v(select_id_uLpDCPSnLength()); return true;
21502                         case 2: v(select_id_dLPDCPSnLength()); return true;
21503                         case 3: v(select_id_new_drb_ID_req()); return true;
21504                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
21505                         }
21506                         return false;
21507
21508                 }
21509                 template<typename V> bool encode(size_t index, V& v) const
21510                 {
21511                         if(index != type) return false;
21512                         switch(type)
21513                         {
21514                         case 1: v(var.as<PDCPSnLength>()); return true;
21515                         case 2: v(var.as<PDCPSnLength>()); return true;
21516                         case 3: v(var.as<NewDRBIDrequest>()); return true;
21517                         }
21518                         return false;
21519
21520                 }
21521                 private:
21522                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21523                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21524                 union union_type
21525                 {
21526                         char dummy1[sizeof(NewDRBIDrequest)];
21527                         char dummy2[sizeof(PDCPSnLength)];
21528
21529                 };
21530                 asn::variant<sizeof(union_type)> var;
21531                 size_t type {0};
21532
21533         };
21534         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21535         {
21536                 size_t get_index() const {return type;}
21537                 bool is_unknown() const { return type == 4; }
21538                 void clear() {type = 0;}
21539                 void select_id_uLpDCPSnLength() { set(optional); type=1;}
21540                 void select_id_dLPDCPSnLength() { set(optional); type=2;}
21541                 void select_id_new_drb_ID_req() { set(optional); type=3;}
21542                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21543                 template<typename V>  bool decode(V& v)
21544                 {
21545                         clear();
21546                         if(!v(ref_nested())) return false;
21547                         if(equal(optional)) { type = 1; return true; }
21548                         else if(equal(optional)) { type = 2; return true; }
21549                         else if(equal(optional)) { type = 3; return true; }
21550                         else { type = 4; return true;}
21551                         return false;
21552
21553                 }
21554                 template<typename V> bool encode(V& v) const
21555                 {
21556                         return v(ref_nested());
21557
21558                 }
21559                 protected:
21560                 template<typename V>  bool decode(size_t index, V& v)
21561                 {
21562                         clear();
21563                         switch(index)
21564                         {
21565                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21566                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21567                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
21568                         case 4: type = 4; return v(ref_nested());
21569                         ref_nested().clear();
21570                         }
21571                         return false;
21572
21573                 }
21574                 template<typename V> bool encode(size_t index, V& v) const
21575                 {
21576                         if(index != type) {return false;} return v(ref_nested());
21577
21578                 }
21579                 private:
21580                 size_t type {0};
21581
21582         };
21583
21584 };
21585 /*
21586 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent ::= SEQUENCE {
21587         requested-MCG-E-RAB-Level-QoS-Parameters                E-RAB-Level-QoS-Parameters                                                                                                      OPTIONAL,
21588         uL-Configuration                                                                ULConfiguration                                                                                                                         OPTIONAL,
21589         sgNB-UL-GTP-TEIDatPDCP                                          GTPtunnelEndpoint                                                                                                                       OPTIONAL,
21590         s1-DL-GTP-TEIDatSgNB                                                    GTPtunnelEndpoint                                                                                                                       OPTIONAL,
21591         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresentExtIEs} }             OPTIONAL,
21592         ...
21593 }
21594 */
21595
21596 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent : asn::sequence<5, 0, true, 5>
21597 {
21598         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent";}
21599         using parent_t = asn::sequence<5, 0, true, 5>;
21600         struct requested_MCG_E_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
21601         {
21602                 static constexpr const char* name() {return "requested_MCG_E_RAB_Level_QoS_Parameters_t";}
21603                 using parent_t = E_RAB_Level_QoS_Parameters;
21604                 static constexpr bool optional = true;
21605
21606         };
21607         requested_MCG_E_RAB_Level_QoS_Parameters_t& set_requested_MCG_E_RAB_Level_QoS_Parameters() { requested_MCG_E_RAB_Level_QoS_Parameters.setpresent(true); return requested_MCG_E_RAB_Level_QoS_Parameters;}
21608         requested_MCG_E_RAB_Level_QoS_Parameters_t const* get_requested_MCG_E_RAB_Level_QoS_Parameters() const {return requested_MCG_E_RAB_Level_QoS_Parameters.is_valid() ? &requested_MCG_E_RAB_Level_QoS_Parameters : nullptr;}
21609         struct uL_Configuration_t : ULConfiguration
21610         {
21611                 static constexpr const char* name() {return "uL_Configuration_t";}
21612                 using parent_t = ULConfiguration;
21613                 static constexpr bool optional = true;
21614
21615         };
21616         uL_Configuration_t& set_uL_Configuration() { uL_Configuration.setpresent(true); return uL_Configuration;}
21617         uL_Configuration_t const* get_uL_Configuration() const {return uL_Configuration.is_valid() ? &uL_Configuration : nullptr;}
21618         struct sgNB_UL_GTP_TEIDatPDCP_t : GTPtunnelEndpoint
21619         {
21620                 static constexpr const char* name() {return "sgNB_UL_GTP_TEIDatPDCP_t";}
21621                 using parent_t = GTPtunnelEndpoint;
21622                 static constexpr bool optional = true;
21623
21624         };
21625         sgNB_UL_GTP_TEIDatPDCP_t& set_sgNB_UL_GTP_TEIDatPDCP() { sgNB_UL_GTP_TEIDatPDCP.setpresent(true); return sgNB_UL_GTP_TEIDatPDCP;}
21626         sgNB_UL_GTP_TEIDatPDCP_t const* get_sgNB_UL_GTP_TEIDatPDCP() const {return sgNB_UL_GTP_TEIDatPDCP.is_valid() ? &sgNB_UL_GTP_TEIDatPDCP : nullptr;}
21627         struct s1_DL_GTP_TEIDatSgNB_t : GTPtunnelEndpoint
21628         {
21629                 static constexpr const char* name() {return "s1_DL_GTP_TEIDatSgNB_t";}
21630                 using parent_t = GTPtunnelEndpoint;
21631                 static constexpr bool optional = true;
21632
21633         };
21634         s1_DL_GTP_TEIDatSgNB_t& set_s1_DL_GTP_TEIDatSgNB() { s1_DL_GTP_TEIDatSgNB.setpresent(true); return s1_DL_GTP_TEIDatSgNB;}
21635         s1_DL_GTP_TEIDatSgNB_t const* get_s1_DL_GTP_TEIDatSgNB() const {return s1_DL_GTP_TEIDatSgNB.is_valid() ? &s1_DL_GTP_TEIDatSgNB : nullptr;}
21636         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>
21637         {
21638                 static constexpr const char* name() {return "iE_Extensions_t";}
21639                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresentExtIEs>;
21640                 static constexpr bool optional = true;
21641
21642         };
21643         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21644         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21645         template<typename V> void decode(V& v)
21646         {
21647                 v(requested_MCG_E_RAB_Level_QoS_Parameters);
21648                 v(uL_Configuration);
21649                 v(sgNB_UL_GTP_TEIDatPDCP);
21650                 v(s1_DL_GTP_TEIDatSgNB);
21651                 v(iE_Extensions);
21652
21653         };
21654         template<typename V> void encode(V& v) const
21655         {
21656                 v(requested_MCG_E_RAB_Level_QoS_Parameters);
21657                 v(uL_Configuration);
21658                 v(sgNB_UL_GTP_TEIDatPDCP);
21659                 v(s1_DL_GTP_TEIDatSgNB);
21660                 v(iE_Extensions);
21661
21662         };
21663         void clear()
21664         {
21665                 requested_MCG_E_RAB_Level_QoS_Parameters.clear();
21666                 uL_Configuration.clear();
21667                 sgNB_UL_GTP_TEIDatPDCP.clear();
21668                 s1_DL_GTP_TEIDatSgNB.clear();
21669                 iE_Extensions.clear();
21670
21671         };
21672         private:
21673         requested_MCG_E_RAB_Level_QoS_Parameters_t      requested_MCG_E_RAB_Level_QoS_Parameters;
21674         uL_Configuration_t      uL_Configuration;
21675         sgNB_UL_GTP_TEIDatPDCP_t        sgNB_UL_GTP_TEIDatPDCP;
21676         s1_DL_GTP_TEIDatSgNB_t  s1_DL_GTP_TEIDatSgNB;
21677         iE_Extensions_t iE_Extensions;
21678
21679 };
21680 /*
21681 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21682         { ID id-RLC-Status                      CRITICALITY ignore                      EXTENSION RLC-Status                            PRESENCE optional}|
21683         { ID id-lCID                            CRITICALITY ignore                      EXTENSION LCID                                          PRESENCE optional},
21684         ...
21685 }
21686 */
21687
21688 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs
21689 {
21690         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21691         {
21692                 size_t get_index() const {return type;}
21693                 bool is_unknown() const { return type == 3; }
21694                 void clear() {type = 0;}
21695                 void select_id_RLC_Status() { set(id_RLC_Status); type=1;}
21696                 void select_id_lCID() { set(id_lCID); type=2;}
21697                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21698                 template<typename V>  bool decode(V& v)
21699                 {
21700                         clear();
21701                         if(!v(ref_nested())) return false;
21702                         if(equal(id_RLC_Status)) { type = 1; return true; }
21703                         else if(equal(id_lCID)) { type = 2; return true; }
21704                         else { type = 3; return true;}
21705                         return false;
21706
21707                 }
21708                 template<typename V> bool encode(V& v) const
21709                 {
21710                         return v(ref_nested());
21711
21712                 }
21713                 protected:
21714                 template<typename V>  bool decode(size_t index, V& v)
21715                 {
21716                         clear();
21717                         switch(index)
21718                         {
21719                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RLC_Status);} return false;
21720                         case 2: type = 2; if(v(ref_nested())) { return equal(id_lCID);} return false;
21721                         case 3: type = 3; return v(ref_nested());
21722                         ref_nested().clear();
21723                         }
21724                         return false;
21725
21726                 }
21727                 template<typename V> bool encode(size_t index, V& v) const
21728                 {
21729                         if(index != type) {return false;} return v(ref_nested());
21730
21731                 }
21732                 private:
21733                 size_t type {0};
21734
21735         };
21736         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21737         {
21738                 size_t get_index() const {return type;}
21739                 bool is_unknown() const { return type == 3; }
21740                 void clear() {type = 0;}
21741                 void select_id_RLC_Status() { set(ignore); type=1;}
21742                 void select_id_lCID() { set(ignore); type=2;}
21743                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21744                 template<typename V>  bool decode(V& v)
21745                 {
21746                         clear();
21747                         if(!v(ref_nested())) return false;
21748                         if(equal(ignore)) { type = 1; return true; }
21749                         else if(equal(ignore)) { type = 2; return true; }
21750                         else { type = 3; return true;}
21751                         return false;
21752
21753                 }
21754                 template<typename V> bool encode(V& v) const
21755                 {
21756                         return v(ref_nested());
21757
21758                 }
21759                 protected:
21760                 template<typename V>  bool decode(size_t index, V& v)
21761                 {
21762                         clear();
21763                         switch(index)
21764                         {
21765                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21766                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21767                         case 3: type = 3; return v(ref_nested());
21768                         ref_nested().clear();
21769                         }
21770                         return false;
21771
21772                 }
21773                 template<typename V> bool encode(size_t index, V& v) const
21774                 {
21775                         if(index != type) {return false;} return v(ref_nested());
21776
21777                 }
21778                 private:
21779                 size_t type {0};
21780
21781         };
21782         struct Extension_t : asn::typefield<true>
21783         {
21784                 ~Extension_t()  {clear();}
21785                 size_t get_index() const {return type;}
21786                 RLC_Status& select_id_RLC_Status() { return set<RLC_Status>(1); }
21787                 RLC_Status const* get_id_RLC_Status() const { return get<RLC_Status>(1); }
21788                 LCID& select_id_lCID() { return set<LCID>(2); }
21789                 LCID const* get_id_lCID() const { return get<LCID>(2); }
21790                 bool is_unknown() const { return type == 3; }
21791                 void clear()
21792                 {
21793                         switch(type)
21794                         {
21795                         case 1: var.destroy<RLC_Status>(); break;
21796                         case 2: var.destroy<LCID>(); break;
21797                         }
21798                         type = 0; ref_nested().clear();
21799                 }
21800                 template<typename V> static inline void enumerate(V& v)
21801                 {
21802                         v.template operator()<RLC_Status>(1);
21803                         v.template operator()<LCID>(2);
21804
21805                 }
21806                 protected:
21807                 template<typename V> bool decode(size_t index, V& v)
21808                 {
21809                         clear();
21810                         switch(index)
21811                         {
21812                         case 1: v(select_id_RLC_Status()); return true;
21813                         case 2: v(select_id_lCID()); return true;
21814                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
21815                         }
21816                         return false;
21817
21818                 }
21819                 template<typename V> bool encode(size_t index, V& v) const
21820                 {
21821                         if(index != type) return false;
21822                         switch(type)
21823                         {
21824                         case 1: v(var.as<RLC_Status>()); return true;
21825                         case 2: v(var.as<LCID>()); return true;
21826                         }
21827                         return false;
21828
21829                 }
21830                 private:
21831                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21832                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21833                 union union_type
21834                 {
21835                         char dummy1[sizeof(LCID)];
21836                         char dummy2[sizeof(RLC_Status)];
21837
21838                 };
21839                 asn::variant<sizeof(union_type)> var;
21840                 size_t type {0};
21841
21842         };
21843         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21844         {
21845                 size_t get_index() const {return type;}
21846                 bool is_unknown() const { return type == 3; }
21847                 void clear() {type = 0;}
21848                 void select_id_RLC_Status() { set(optional); type=1;}
21849                 void select_id_lCID() { set(optional); type=2;}
21850                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21851                 template<typename V>  bool decode(V& v)
21852                 {
21853                         clear();
21854                         if(!v(ref_nested())) return false;
21855                         if(equal(optional)) { type = 1; return true; }
21856                         else if(equal(optional)) { type = 2; return true; }
21857                         else { type = 3; return true;}
21858                         return false;
21859
21860                 }
21861                 template<typename V> bool encode(V& v) const
21862                 {
21863                         return v(ref_nested());
21864
21865                 }
21866                 protected:
21867                 template<typename V>  bool decode(size_t index, V& v)
21868                 {
21869                         clear();
21870                         switch(index)
21871                         {
21872                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21873                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21874                         case 3: type = 3; return v(ref_nested());
21875                         ref_nested().clear();
21876                         }
21877                         return false;
21878
21879                 }
21880                 template<typename V> bool encode(size_t index, V& v) const
21881                 {
21882                         if(index != type) {return false;} return v(ref_nested());
21883
21884                 }
21885                 private:
21886                 size_t type {0};
21887
21888         };
21889
21890 };
21891 /*
21892 E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent ::= SEQUENCE {
21893         sgNB-DL-GTP-TEIDatSCG                           GTPtunnelEndpoint                               OPTIONAL,
21894         secondary-sgNB-DL-GTP-TEIDatSCG         GTPtunnelEndpoint                               OPTIONAL,
21895         iE-Extensions                           ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresentExtIEs} }          OPTIONAL,
21896         ...
21897 }
21898 */
21899
21900 struct E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent : asn::sequence<3, 0, true, 3>
21901 {
21902         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent";}
21903         using parent_t = asn::sequence<3, 0, true, 3>;
21904         struct sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
21905         {
21906                 static constexpr const char* name() {return "sgNB_DL_GTP_TEIDatSCG_t";}
21907                 using parent_t = GTPtunnelEndpoint;
21908                 static constexpr bool optional = true;
21909
21910         };
21911         sgNB_DL_GTP_TEIDatSCG_t& set_sgNB_DL_GTP_TEIDatSCG() { sgNB_DL_GTP_TEIDatSCG.setpresent(true); return sgNB_DL_GTP_TEIDatSCG;}
21912         sgNB_DL_GTP_TEIDatSCG_t const* get_sgNB_DL_GTP_TEIDatSCG() const {return sgNB_DL_GTP_TEIDatSCG.is_valid() ? &sgNB_DL_GTP_TEIDatSCG : nullptr;}
21913         struct secondary_sgNB_DL_GTP_TEIDatSCG_t : GTPtunnelEndpoint
21914         {
21915                 static constexpr const char* name() {return "secondary_sgNB_DL_GTP_TEIDatSCG_t";}
21916                 using parent_t = GTPtunnelEndpoint;
21917                 static constexpr bool optional = true;
21918
21919         };
21920         secondary_sgNB_DL_GTP_TEIDatSCG_t& set_secondary_sgNB_DL_GTP_TEIDatSCG() { secondary_sgNB_DL_GTP_TEIDatSCG.setpresent(true); return secondary_sgNB_DL_GTP_TEIDatSCG;}
21921         secondary_sgNB_DL_GTP_TEIDatSCG_t const* get_secondary_sgNB_DL_GTP_TEIDatSCG() const {return secondary_sgNB_DL_GTP_TEIDatSCG.is_valid() ? &secondary_sgNB_DL_GTP_TEIDatSCG : nullptr;}
21922         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>
21923         {
21924                 static constexpr const char* name() {return "iE_Extensions_t";}
21925                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresentExtIEs>;
21926                 static constexpr bool optional = true;
21927
21928         };
21929         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21930         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21931         template<typename V> void decode(V& v)
21932         {
21933                 v(sgNB_DL_GTP_TEIDatSCG);
21934                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
21935                 v(iE_Extensions);
21936
21937         };
21938         template<typename V> void encode(V& v) const
21939         {
21940                 v(sgNB_DL_GTP_TEIDatSCG);
21941                 v(secondary_sgNB_DL_GTP_TEIDatSCG);
21942                 v(iE_Extensions);
21943
21944         };
21945         void clear()
21946         {
21947                 sgNB_DL_GTP_TEIDatSCG.clear();
21948                 secondary_sgNB_DL_GTP_TEIDatSCG.clear();
21949                 iE_Extensions.clear();
21950
21951         };
21952         private:
21953         sgNB_DL_GTP_TEIDatSCG_t sgNB_DL_GTP_TEIDatSCG;
21954         secondary_sgNB_DL_GTP_TEIDatSCG_t       secondary_sgNB_DL_GTP_TEIDatSCG;
21955         iE_Extensions_t iE_Extensions;
21956
21957 };
21958 /*
21959 E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21960         ...
21961 }
21962 */
21963
21964 struct E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs
21965 {
21966         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21967         {
21968                 size_t get_index() const {return type;}
21969                 bool is_unknown() const { return type == 1; }
21970                 void clear() {type = 0;}
21971                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21972                 template<typename V>  bool decode(V& v)
21973                 {
21974                         clear();
21975                         if(!v(ref_nested())) return false;
21976                         { type = 1; return true;}
21977                         return false;
21978
21979                 }
21980                 template<typename V> bool encode(V& v) const
21981                 {
21982                         return v(ref_nested());
21983
21984                 }
21985                 protected:
21986                 template<typename V>  bool decode(size_t index, V& v)
21987                 {
21988                         clear();
21989                         switch(index)
21990                         {
21991                         case 1: type = 1; return v(ref_nested());
21992                         ref_nested().clear();
21993                         }
21994                         return false;
21995
21996                 }
21997                 template<typename V> bool encode(size_t index, V& v) const
21998                 {
21999                         if(index != type) {return false;} return v(ref_nested());
22000
22001                 }
22002                 private:
22003                 size_t type {0};
22004
22005         };
22006         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22007         {
22008                 size_t get_index() const {return type;}
22009                 bool is_unknown() const { return type == 1; }
22010                 void clear() {type = 0;}
22011                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22012                 template<typename V>  bool decode(V& v)
22013                 {
22014                         clear();
22015                         if(!v(ref_nested())) return false;
22016                         { type = 1; return true;}
22017                         return false;
22018
22019                 }
22020                 template<typename V> bool encode(V& v) const
22021                 {
22022                         return v(ref_nested());
22023
22024                 }
22025                 protected:
22026                 template<typename V>  bool decode(size_t index, V& v)
22027                 {
22028                         clear();
22029                         switch(index)
22030                         {
22031                         case 1: type = 1; return v(ref_nested());
22032                         ref_nested().clear();
22033                         }
22034                         return false;
22035
22036                 }
22037                 template<typename V> bool encode(size_t index, V& v) const
22038                 {
22039                         if(index != type) {return false;} return v(ref_nested());
22040
22041                 }
22042                 private:
22043                 size_t type {0};
22044
22045         };
22046         struct Extension_t : asn::typefield<true>
22047         {
22048                 ~Extension_t()  {clear();}
22049                 size_t get_index() const {return type;}
22050                 bool is_unknown() const { return type == 1; }
22051                 void clear()
22052                 {
22053                         type = 0; ref_nested().clear();
22054                 }
22055                 template<typename V> static inline void enumerate(V& v)
22056                 {
22057
22058                 }
22059                 protected:
22060                 template<typename V> bool decode(size_t index, V& v)
22061                 {
22062                         clear();
22063                         switch(index)
22064                         {
22065                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22066                         }
22067                         return false;
22068
22069                 }
22070                 template<typename V> bool encode(size_t index, V& v) const
22071                 {
22072                         if(index != type) return false;
22073                         return false;
22074
22075                 }
22076                 private:
22077                 size_t type {0};
22078
22079         };
22080         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22081         {
22082                 size_t get_index() const {return type;}
22083                 bool is_unknown() const { return type == 1; }
22084                 void clear() {type = 0;}
22085                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22086                 template<typename V>  bool decode(V& v)
22087                 {
22088                         clear();
22089                         if(!v(ref_nested())) return false;
22090                         { type = 1; return true;}
22091                         return false;
22092
22093                 }
22094                 template<typename V> bool encode(V& v) const
22095                 {
22096                         return v(ref_nested());
22097
22098                 }
22099                 protected:
22100                 template<typename V>  bool decode(size_t index, V& v)
22101                 {
22102                         clear();
22103                         switch(index)
22104                         {
22105                         case 1: type = 1; return v(ref_nested());
22106                         ref_nested().clear();
22107                         }
22108                         return false;
22109
22110                 }
22111                 template<typename V> bool encode(size_t index, V& v) const
22112                 {
22113                         if(index != type) {return false;} return v(ref_nested());
22114
22115                 }
22116                 private:
22117                 size_t type {0};
22118
22119         };
22120
22121 };
22122 /*
22123 E-RABs-ToBeModified-SgNBModReqd-Item ::= SEQUENCE {
22124         e-RAB-ID                                                                E-RAB-ID,
22125         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
22126         resource-configuration                          CHOICE {
22127                 sgNBPDCPpresent                                         E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPpresent,
22128                 sgNBPDCPnotpresent                                      E-RABs-ToBeModified-SgNBModReqd-Item-SgNBPDCPnotpresent,
22129                 ...
22130         },
22131         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeModified-SgNBModReqd-ItemExtIEs} }     OPTIONAL,
22132         ...
22133 }
22134 */
22135
22136 struct E_RABs_ToBeModified_SgNBModReqd_Item : asn::sequence<4, 0, true, 1>
22137 {
22138         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqd-Item";}
22139         using parent_t = asn::sequence<4, 0, true, 1>;
22140         struct e_RAB_ID_t : E_RAB_ID
22141         {
22142                 static constexpr const char* name() {return "e_RAB_ID_t";}
22143                 using parent_t = E_RAB_ID;
22144
22145         };
22146         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22147         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22148         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
22149         {
22150                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
22151                 using parent_t = EN_DC_ResourceConfiguration;
22152
22153         };
22154         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
22155         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
22156         struct resource_configuration_t : asn::choice<2, 0, true>
22157         {
22158                 static constexpr const char* name() {return "resource_configuration_t";}
22159                 using parent_t = asn::choice<2, 0, true>;
22160                 index_type get_index() const {return index;}
22161                 bool is_unknown() const {return index == 3;}
22162                 void set_unknown() { set_index(3);  }
22163                 ~resource_configuration_t() {clear();}
22164                 struct sgNBPDCPpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent
22165                 {
22166                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
22167                         using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPpresent;
22168
22169                 };
22170                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent
22171                 {
22172                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
22173                         using parent_t = E_RABs_ToBeModified_SgNBModReqd_Item_SgNBPDCPnotpresent;
22174
22175                 };
22176                 void clear()
22177                 {
22178                         switch(get_index())
22179                         {
22180                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
22181                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
22182                         }
22183                         index = 0;
22184                         base::clear();
22185                 }
22186                 template<typename V> bool decode(size_t idx, V& v)
22187                 {
22188                         clear();
22189                         switch(idx)
22190                         {
22191                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
22192                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
22193                         }
22194                         return false;
22195
22196                 }
22197                 template<typename V> bool encode(V& v) const
22198                 {
22199                         switch(get_index())
22200                         {
22201                         case 1: return v(var.as<sgNBPDCPpresent_t>());
22202                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
22203                         }
22204                         return false;
22205                 }
22206                 template<typename V> static inline void enumerate(V& v)
22207                 {
22208                         v.template operator()<sgNBPDCPpresent_t>(1);
22209                         v.template operator()<sgNBPDCPnotpresent_t>(2);
22210
22211                 }
22212                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
22213                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
22214                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
22215                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
22216                 private:
22217                 void set_index(index_type i) {index = i; base::set();}
22218                 union union_type
22219                 {
22220                         char dummy1[sizeof(sgNBPDCPpresent_t)];
22221                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
22222
22223                 };
22224                 asn::variant<sizeof(union_type)>        var;
22225                 index_type      index {0};
22226         };
22227         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
22228         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
22229         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>
22230         {
22231                 static constexpr const char* name() {return "iE_Extensions_t";}
22232                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeModified_SgNBModReqd_ItemExtIEs>;
22233                 static constexpr bool optional = true;
22234
22235         };
22236         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22237         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22238         template<typename V> void decode(V& v)
22239         {
22240                 v(e_RAB_ID);
22241                 v(en_DC_ResourceConfiguration);
22242                 v(resource_configuration);
22243                 v(iE_Extensions);
22244
22245         };
22246         template<typename V> void encode(V& v) const
22247         {
22248                 v(e_RAB_ID);
22249                 v(en_DC_ResourceConfiguration);
22250                 v(resource_configuration);
22251                 v(iE_Extensions);
22252
22253         };
22254         void clear()
22255         {
22256                 e_RAB_ID.clear();
22257                 en_DC_ResourceConfiguration.clear();
22258                 resource_configuration.clear();
22259                 iE_Extensions.clear();
22260
22261         };
22262         private:
22263         e_RAB_ID_t      e_RAB_ID;
22264         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
22265         resource_configuration_t        resource_configuration;
22266         iE_Extensions_t iE_Extensions;
22267
22268 };
22269 /*
22270 E-RABs-ToBeModified-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
22271         { ID id-E-RABs-ToBeModified-SgNBModReqd-Item     CRITICALITY ignore             TYPE E-RABs-ToBeModified-SgNBModReqd-Item               PRESENCE mandatory },
22272         ...
22273 }
22274 */
22275
22276 struct E_RABs_ToBeModified_SgNBModReqd_ItemIEs
22277 {
22278         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
22279         {
22280                 size_t get_index() const {return type;}
22281                 bool is_unknown() const { return type == 2; }
22282                 void clear() {type = 0;}
22283                 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(id_E_RABs_ToBeModified_SgNBModReqd_Item); type=1;}
22284                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
22285                 template<typename V>  bool decode(V& v)
22286                 {
22287                         clear();
22288                         if(!v(ref_nested())) return false;
22289                         if(equal(id_E_RABs_ToBeModified_SgNBModReqd_Item)) { type = 1; return true; }
22290                         else { type = 2; return true;}
22291                         return false;
22292
22293                 }
22294                 template<typename V> bool encode(V& v) const
22295                 {
22296                         return v(ref_nested());
22297
22298                 }
22299                 protected:
22300                 template<typename V>  bool decode(size_t index, V& v)
22301                 {
22302                         clear();
22303                         switch(index)
22304                         {
22305                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReqd_Item);} return false;
22306                         case 2: type = 2; return v(ref_nested());
22307                         ref_nested().clear();
22308                         }
22309                         return false;
22310
22311                 }
22312                 template<typename V> bool encode(size_t index, V& v) const
22313                 {
22314                         if(index != type) {return false;} return v(ref_nested());
22315
22316                 }
22317                 private:
22318                 size_t type {0};
22319
22320         };
22321         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
22322         {
22323                 size_t get_index() const {return type;}
22324                 bool is_unknown() const { return type == 2; }
22325                 void clear() {type = 0;}
22326                 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(ignore); type=1;}
22327                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
22328                 template<typename V>  bool decode(V& v)
22329                 {
22330                         clear();
22331                         if(!v(ref_nested())) return false;
22332                         if(equal(ignore)) { type = 1; return true; }
22333                         else { type = 2; return true;}
22334                         return false;
22335
22336                 }
22337                 template<typename V> bool encode(V& v) const
22338                 {
22339                         return v(ref_nested());
22340
22341                 }
22342                 protected:
22343                 template<typename V>  bool decode(size_t index, V& v)
22344                 {
22345                         clear();
22346                         switch(index)
22347                         {
22348                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
22349                         case 2: type = 2; return v(ref_nested());
22350                         ref_nested().clear();
22351                         }
22352                         return false;
22353
22354                 }
22355                 template<typename V> bool encode(size_t index, V& v) const
22356                 {
22357                         if(index != type) {return false;} return v(ref_nested());
22358
22359                 }
22360                 private:
22361                 size_t type {0};
22362
22363         };
22364         struct Value_t : asn::typefield<true>
22365         {
22366                 ~Value_t()      {clear();}
22367                 size_t get_index() const {return type;}
22368                 E_RABs_ToBeModified_SgNBModReqd_Item& select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { return set<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
22369                 E_RABs_ToBeModified_SgNBModReqd_Item const* get_id_E_RABs_ToBeModified_SgNBModReqd_Item() const { return get<E_RABs_ToBeModified_SgNBModReqd_Item>(1); }
22370                 bool is_unknown() const { return type == 2; }
22371                 void clear()
22372                 {
22373                         switch(type)
22374                         {
22375                         case 1: var.destroy<E_RABs_ToBeModified_SgNBModReqd_Item>(); break;
22376                         }
22377                         type = 0; ref_nested().clear();
22378                 }
22379                 template<typename V> static inline void enumerate(V& v)
22380                 {
22381                         v.template operator()<E_RABs_ToBeModified_SgNBModReqd_Item>(1);
22382
22383                 }
22384                 protected:
22385                 template<typename V> bool decode(size_t index, V& v)
22386                 {
22387                         clear();
22388                         switch(index)
22389                         {
22390                         case 1: v(select_id_E_RABs_ToBeModified_SgNBModReqd_Item()); return true;
22391                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
22392                         }
22393                         return false;
22394
22395                 }
22396                 template<typename V> bool encode(size_t index, V& v) const
22397                 {
22398                         if(index != type) return false;
22399                         switch(type)
22400                         {
22401                         case 1: v(var.as<E_RABs_ToBeModified_SgNBModReqd_Item>()); return true;
22402                         }
22403                         return false;
22404
22405                 }
22406                 private:
22407                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
22408                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
22409                 union union_type
22410                 {
22411                         char dummy1[sizeof(E_RABs_ToBeModified_SgNBModReqd_Item)];
22412
22413                 };
22414                 asn::variant<sizeof(union_type)> var;
22415                 size_t type {0};
22416
22417         };
22418         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
22419         {
22420                 size_t get_index() const {return type;}
22421                 bool is_unknown() const { return type == 2; }
22422                 void clear() {type = 0;}
22423                 void select_id_E_RABs_ToBeModified_SgNBModReqd_Item() { set(mandatory); type=1;}
22424                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
22425                 template<typename V>  bool decode(V& v)
22426                 {
22427                         clear();
22428                         if(!v(ref_nested())) return false;
22429                         if(equal(mandatory)) { type = 1; return true; }
22430                         else { type = 2; return true;}
22431                         return false;
22432
22433                 }
22434                 template<typename V> bool encode(V& v) const
22435                 {
22436                         return v(ref_nested());
22437
22438                 }
22439                 protected:
22440                 template<typename V>  bool decode(size_t index, V& v)
22441                 {
22442                         clear();
22443                         switch(index)
22444                         {
22445                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
22446                         case 2: type = 2; return v(ref_nested());
22447                         ref_nested().clear();
22448                         }
22449                         return false;
22450
22451                 }
22452                 template<typename V> bool encode(size_t index, V& v) const
22453                 {
22454                         if(index != type) {return false;} return v(ref_nested());
22455
22456                 }
22457                 private:
22458                 size_t type {0};
22459
22460         };
22461
22462 };
22463 /*
22464 E-RABs-ToBeModified-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeModified-SgNBModReqd-ItemIEs} }
22465 */
22466
22467 struct E_RABs_ToBeModified_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>
22468 {
22469         static constexpr const char* name() {return "E_RABs_ToBeModified_SgNBModReqdList_elm";}
22470         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeModified_SgNBModReqd_ItemIEs>;
22471
22472 };
22473 struct E_RABs_ToBeModified_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>
22474 {
22475         static constexpr const char* name() {return "E-RABs-ToBeModified-SgNBModReqdList";}
22476         using parent_t = asn::sequenceof<E_RABs_ToBeModified_SgNBModReqdList_elm>;
22477         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
22478
22479 };
22480 /*
22481 E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22482         ...
22483 }
22484 */
22485
22486 struct E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs
22487 {
22488         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22489         {
22490                 size_t get_index() const {return type;}
22491                 bool is_unknown() const { return type == 1; }
22492                 void clear() {type = 0;}
22493                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22494                 template<typename V>  bool decode(V& v)
22495                 {
22496                         clear();
22497                         if(!v(ref_nested())) return false;
22498                         { type = 1; return true;}
22499                         return false;
22500
22501                 }
22502                 template<typename V> bool encode(V& v) const
22503                 {
22504                         return v(ref_nested());
22505
22506                 }
22507                 protected:
22508                 template<typename V>  bool decode(size_t index, V& v)
22509                 {
22510                         clear();
22511                         switch(index)
22512                         {
22513                         case 1: type = 1; return v(ref_nested());
22514                         ref_nested().clear();
22515                         }
22516                         return false;
22517
22518                 }
22519                 template<typename V> bool encode(size_t index, V& v) const
22520                 {
22521                         if(index != type) {return false;} return v(ref_nested());
22522
22523                 }
22524                 private:
22525                 size_t type {0};
22526
22527         };
22528         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22529         {
22530                 size_t get_index() const {return type;}
22531                 bool is_unknown() const { return type == 1; }
22532                 void clear() {type = 0;}
22533                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22534                 template<typename V>  bool decode(V& v)
22535                 {
22536                         clear();
22537                         if(!v(ref_nested())) return false;
22538                         { type = 1; return true;}
22539                         return false;
22540
22541                 }
22542                 template<typename V> bool encode(V& v) const
22543                 {
22544                         return v(ref_nested());
22545
22546                 }
22547                 protected:
22548                 template<typename V>  bool decode(size_t index, V& v)
22549                 {
22550                         clear();
22551                         switch(index)
22552                         {
22553                         case 1: type = 1; return v(ref_nested());
22554                         ref_nested().clear();
22555                         }
22556                         return false;
22557
22558                 }
22559                 template<typename V> bool encode(size_t index, V& v) const
22560                 {
22561                         if(index != type) {return false;} return v(ref_nested());
22562
22563                 }
22564                 private:
22565                 size_t type {0};
22566
22567         };
22568         struct Extension_t : asn::typefield<true>
22569         {
22570                 ~Extension_t()  {clear();}
22571                 size_t get_index() const {return type;}
22572                 bool is_unknown() const { return type == 1; }
22573                 void clear()
22574                 {
22575                         type = 0; ref_nested().clear();
22576                 }
22577                 template<typename V> static inline void enumerate(V& v)
22578                 {
22579
22580                 }
22581                 protected:
22582                 template<typename V> bool decode(size_t index, V& v)
22583                 {
22584                         clear();
22585                         switch(index)
22586                         {
22587                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22588                         }
22589                         return false;
22590
22591                 }
22592                 template<typename V> bool encode(size_t index, V& v) const
22593                 {
22594                         if(index != type) return false;
22595                         return false;
22596
22597                 }
22598                 private:
22599                 size_t type {0};
22600
22601         };
22602         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22603         {
22604                 size_t get_index() const {return type;}
22605                 bool is_unknown() const { return type == 1; }
22606                 void clear() {type = 0;}
22607                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22608                 template<typename V>  bool decode(V& v)
22609                 {
22610                         clear();
22611                         if(!v(ref_nested())) return false;
22612                         { type = 1; return true;}
22613                         return false;
22614
22615                 }
22616                 template<typename V> bool encode(V& v) const
22617                 {
22618                         return v(ref_nested());
22619
22620                 }
22621                 protected:
22622                 template<typename V>  bool decode(size_t index, V& v)
22623                 {
22624                         clear();
22625                         switch(index)
22626                         {
22627                         case 1: type = 1; return v(ref_nested());
22628                         ref_nested().clear();
22629                         }
22630                         return false;
22631
22632                 }
22633                 template<typename V> bool encode(size_t index, V& v) const
22634                 {
22635                         if(index != type) {return false;} return v(ref_nested());
22636
22637                 }
22638                 private:
22639                 size_t type {0};
22640
22641         };
22642
22643 };
22644 /*
22645 E-RABs-ToBeReleased-ModReqItem-SCG-Bearer ::= SEQUENCE {
22646         e-RAB-ID                                                E-RAB-ID,
22647         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
22648         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
22649         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-SCG-BearerExtIEs} } OPTIONAL,
22650         ...
22651 }
22652 */
22653
22654 struct E_RABs_ToBeReleased_ModReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
22655 {
22656         static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-SCG-Bearer";}
22657         using parent_t = asn::sequence<4, 0, true, 3>;
22658         struct e_RAB_ID_t : E_RAB_ID
22659         {
22660                 static constexpr const char* name() {return "e_RAB_ID_t";}
22661                 using parent_t = E_RAB_ID;
22662
22663         };
22664         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22665         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22666         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22667         {
22668                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
22669                 using parent_t = GTPtunnelEndpoint;
22670                 static constexpr bool optional = true;
22671
22672         };
22673         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
22674         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
22675         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22676         {
22677                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
22678                 using parent_t = GTPtunnelEndpoint;
22679                 static constexpr bool optional = true;
22680
22681         };
22682         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
22683         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
22684         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>
22685         {
22686                 static constexpr const char* name() {return "iE_Extensions_t";}
22687                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_SCG_BearerExtIEs>;
22688                 static constexpr bool optional = true;
22689
22690         };
22691         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22692         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22693         template<typename V> void decode(V& v)
22694         {
22695                 v(e_RAB_ID);
22696                 v(dL_Forwarding_GTPtunnelEndpoint);
22697                 v(uL_Forwarding_GTPtunnelEndpoint);
22698                 v(iE_Extensions);
22699
22700         };
22701         template<typename V> void encode(V& v) const
22702         {
22703                 v(e_RAB_ID);
22704                 v(dL_Forwarding_GTPtunnelEndpoint);
22705                 v(uL_Forwarding_GTPtunnelEndpoint);
22706                 v(iE_Extensions);
22707
22708         };
22709         void clear()
22710         {
22711                 e_RAB_ID.clear();
22712                 dL_Forwarding_GTPtunnelEndpoint.clear();
22713                 uL_Forwarding_GTPtunnelEndpoint.clear();
22714                 iE_Extensions.clear();
22715
22716         };
22717         private:
22718         e_RAB_ID_t      e_RAB_ID;
22719         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
22720         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
22721         iE_Extensions_t iE_Extensions;
22722
22723 };
22724 /*
22725 E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22726         ...
22727 }
22728 */
22729
22730 struct E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs
22731 {
22732         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22733         {
22734                 size_t get_index() const {return type;}
22735                 bool is_unknown() const { return type == 1; }
22736                 void clear() {type = 0;}
22737                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22738                 template<typename V>  bool decode(V& v)
22739                 {
22740                         clear();
22741                         if(!v(ref_nested())) return false;
22742                         { type = 1; return true;}
22743                         return false;
22744
22745                 }
22746                 template<typename V> bool encode(V& v) const
22747                 {
22748                         return v(ref_nested());
22749
22750                 }
22751                 protected:
22752                 template<typename V>  bool decode(size_t index, V& v)
22753                 {
22754                         clear();
22755                         switch(index)
22756                         {
22757                         case 1: type = 1; return v(ref_nested());
22758                         ref_nested().clear();
22759                         }
22760                         return false;
22761
22762                 }
22763                 template<typename V> bool encode(size_t index, V& v) const
22764                 {
22765                         if(index != type) {return false;} return v(ref_nested());
22766
22767                 }
22768                 private:
22769                 size_t type {0};
22770
22771         };
22772         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22773         {
22774                 size_t get_index() const {return type;}
22775                 bool is_unknown() const { return type == 1; }
22776                 void clear() {type = 0;}
22777                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22778                 template<typename V>  bool decode(V& v)
22779                 {
22780                         clear();
22781                         if(!v(ref_nested())) return false;
22782                         { type = 1; return true;}
22783                         return false;
22784
22785                 }
22786                 template<typename V> bool encode(V& v) const
22787                 {
22788                         return v(ref_nested());
22789
22790                 }
22791                 protected:
22792                 template<typename V>  bool decode(size_t index, V& v)
22793                 {
22794                         clear();
22795                         switch(index)
22796                         {
22797                         case 1: type = 1; return v(ref_nested());
22798                         ref_nested().clear();
22799                         }
22800                         return false;
22801
22802                 }
22803                 template<typename V> bool encode(size_t index, V& v) const
22804                 {
22805                         if(index != type) {return false;} return v(ref_nested());
22806
22807                 }
22808                 private:
22809                 size_t type {0};
22810
22811         };
22812         struct Extension_t : asn::typefield<true>
22813         {
22814                 ~Extension_t()  {clear();}
22815                 size_t get_index() const {return type;}
22816                 bool is_unknown() const { return type == 1; }
22817                 void clear()
22818                 {
22819                         type = 0; ref_nested().clear();
22820                 }
22821                 template<typename V> static inline void enumerate(V& v)
22822                 {
22823
22824                 }
22825                 protected:
22826                 template<typename V> bool decode(size_t index, V& v)
22827                 {
22828                         clear();
22829                         switch(index)
22830                         {
22831                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22832                         }
22833                         return false;
22834
22835                 }
22836                 template<typename V> bool encode(size_t index, V& v) const
22837                 {
22838                         if(index != type) return false;
22839                         return false;
22840
22841                 }
22842                 private:
22843                 size_t type {0};
22844
22845         };
22846         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22847         {
22848                 size_t get_index() const {return type;}
22849                 bool is_unknown() const { return type == 1; }
22850                 void clear() {type = 0;}
22851                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22852                 template<typename V>  bool decode(V& v)
22853                 {
22854                         clear();
22855                         if(!v(ref_nested())) return false;
22856                         { type = 1; return true;}
22857                         return false;
22858
22859                 }
22860                 template<typename V> bool encode(V& v) const
22861                 {
22862                         return v(ref_nested());
22863
22864                 }
22865                 protected:
22866                 template<typename V>  bool decode(size_t index, V& v)
22867                 {
22868                         clear();
22869                         switch(index)
22870                         {
22871                         case 1: type = 1; return v(ref_nested());
22872                         ref_nested().clear();
22873                         }
22874                         return false;
22875
22876                 }
22877                 template<typename V> bool encode(size_t index, V& v) const
22878                 {
22879                         if(index != type) {return false;} return v(ref_nested());
22880
22881                 }
22882                 private:
22883                 size_t type {0};
22884
22885         };
22886
22887 };
22888 /*
22889 E-RABs-ToBeReleased-ModReqItem-Split-Bearer ::= SEQUENCE {
22890         e-RAB-ID                                                E-RAB-ID,
22891         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
22892         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqItem-Split-BearerExtIEs} } OPTIONAL,
22893         ...
22894 }
22895 */
22896
22897 struct E_RABs_ToBeReleased_ModReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
22898 {
22899         static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem-Split-Bearer";}
22900         using parent_t = asn::sequence<3, 0, true, 2>;
22901         struct e_RAB_ID_t : E_RAB_ID
22902         {
22903                 static constexpr const char* name() {return "e_RAB_ID_t";}
22904                 using parent_t = E_RAB_ID;
22905
22906         };
22907         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
22908         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
22909         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
22910         {
22911                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
22912                 using parent_t = GTPtunnelEndpoint;
22913                 static constexpr bool optional = true;
22914
22915         };
22916         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
22917         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
22918         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>
22919         {
22920                 static constexpr const char* name() {return "iE_Extensions_t";}
22921                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqItem_Split_BearerExtIEs>;
22922                 static constexpr bool optional = true;
22923
22924         };
22925         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22926         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22927         template<typename V> void decode(V& v)
22928         {
22929                 v(e_RAB_ID);
22930                 v(dL_Forwarding_GTPtunnelEndpoint);
22931                 v(iE_Extensions);
22932
22933         };
22934         template<typename V> void encode(V& v) const
22935         {
22936                 v(e_RAB_ID);
22937                 v(dL_Forwarding_GTPtunnelEndpoint);
22938                 v(iE_Extensions);
22939
22940         };
22941         void clear()
22942         {
22943                 e_RAB_ID.clear();
22944                 dL_Forwarding_GTPtunnelEndpoint.clear();
22945                 iE_Extensions.clear();
22946
22947         };
22948         private:
22949         e_RAB_ID_t      e_RAB_ID;
22950         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
22951         iE_Extensions_t iE_Extensions;
22952
22953 };
22954 /*
22955 E-RABs-ToBeReleased-ModReqItem ::= CHOICE {
22956         sCG-Bearer              E-RABs-ToBeReleased-ModReqItem-SCG-Bearer,
22957         split-Bearer    E-RABs-ToBeReleased-ModReqItem-Split-Bearer,
22958         ...
22959 }
22960 */
22961
22962 struct E_RABs_ToBeReleased_ModReqItem : asn::choice<2, 0, true>
22963 {
22964         static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqItem";}
22965         using parent_t = asn::choice<2, 0, true>;
22966         index_type get_index() const {return index;}
22967         bool is_unknown() const {return index == 3;}
22968         void set_unknown() { set_index(3);  }
22969         ~E_RABs_ToBeReleased_ModReqItem() {clear();}
22970         struct sCG_Bearer_t : E_RABs_ToBeReleased_ModReqItem_SCG_Bearer
22971         {
22972                 static constexpr const char* name() {return "sCG_Bearer_t";}
22973                 using parent_t = E_RABs_ToBeReleased_ModReqItem_SCG_Bearer;
22974
22975         };
22976         struct split_Bearer_t : E_RABs_ToBeReleased_ModReqItem_Split_Bearer
22977         {
22978                 static constexpr const char* name() {return "split_Bearer_t";}
22979                 using parent_t = E_RABs_ToBeReleased_ModReqItem_Split_Bearer;
22980
22981         };
22982         void clear()
22983         {
22984                 switch(get_index())
22985                 {
22986                 case 1: var.destroy<sCG_Bearer_t>(); break;
22987                 case 2: var.destroy<split_Bearer_t>(); break;
22988                 }
22989                 index = 0;
22990                 base::clear();
22991         }
22992         template<typename V> bool decode(size_t idx, V& v)
22993         {
22994                 clear();
22995                 switch(idx)
22996                 {
22997                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
22998                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
22999                 }
23000                 return false;
23001
23002         }
23003         template<typename V> bool encode(V& v) const
23004         {
23005                 switch(get_index())
23006                 {
23007                 case 1: return v(var.as<sCG_Bearer_t>());
23008                 case 2: return v(var.as<split_Bearer_t>());
23009                 }
23010                 return false;
23011         }
23012         template<typename V> static inline void enumerate(V& v)
23013         {
23014                 v.template operator()<sCG_Bearer_t>(1);
23015                 v.template operator()<split_Bearer_t>(2);
23016
23017         }
23018         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
23019         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
23020         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
23021         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
23022         private:
23023         void set_index(index_type i) {index = i; base::set();}
23024         union union_type
23025         {
23026                 char dummy1[sizeof(sCG_Bearer_t)];
23027                 char dummy2[sizeof(split_Bearer_t)];
23028
23029         };
23030         asn::variant<sizeof(union_type)>        var;
23031         index_type      index {0};
23032 };
23033 /*
23034 E-RABs-ToBeReleased-ModReqItemIEs X2AP-PROTOCOL-IES ::= {
23035         { ID id-E-RABs-ToBeReleased-ModReqItem  CRITICALITY ignore      TYPE E-RABs-ToBeReleased-ModReqItem             PRESENCE mandatory},
23036         ...
23037 }
23038 */
23039
23040 struct E_RABs_ToBeReleased_ModReqItemIEs
23041 {
23042         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
23043         {
23044                 size_t get_index() const {return type;}
23045                 bool is_unknown() const { return type == 2; }
23046                 void clear() {type = 0;}
23047                 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(id_E_RABs_ToBeReleased_ModReqItem); type=1;}
23048                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
23049                 template<typename V>  bool decode(V& v)
23050                 {
23051                         clear();
23052                         if(!v(ref_nested())) return false;
23053                         if(equal(id_E_RABs_ToBeReleased_ModReqItem)) { type = 1; return true; }
23054                         else { type = 2; return true;}
23055                         return false;
23056
23057                 }
23058                 template<typename V> bool encode(V& v) const
23059                 {
23060                         return v(ref_nested());
23061
23062                 }
23063                 protected:
23064                 template<typename V>  bool decode(size_t index, V& v)
23065                 {
23066                         clear();
23067                         switch(index)
23068                         {
23069                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqItem);} return false;
23070                         case 2: type = 2; return v(ref_nested());
23071                         ref_nested().clear();
23072                         }
23073                         return false;
23074
23075                 }
23076                 template<typename V> bool encode(size_t index, V& v) const
23077                 {
23078                         if(index != type) {return false;} return v(ref_nested());
23079
23080                 }
23081                 private:
23082                 size_t type {0};
23083
23084         };
23085         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
23086         {
23087                 size_t get_index() const {return type;}
23088                 bool is_unknown() const { return type == 2; }
23089                 void clear() {type = 0;}
23090                 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(ignore); type=1;}
23091                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
23092                 template<typename V>  bool decode(V& v)
23093                 {
23094                         clear();
23095                         if(!v(ref_nested())) return false;
23096                         if(equal(ignore)) { type = 1; return true; }
23097                         else { type = 2; return true;}
23098                         return false;
23099
23100                 }
23101                 template<typename V> bool encode(V& v) const
23102                 {
23103                         return v(ref_nested());
23104
23105                 }
23106                 protected:
23107                 template<typename V>  bool decode(size_t index, V& v)
23108                 {
23109                         clear();
23110                         switch(index)
23111                         {
23112                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
23113                         case 2: type = 2; return v(ref_nested());
23114                         ref_nested().clear();
23115                         }
23116                         return false;
23117
23118                 }
23119                 template<typename V> bool encode(size_t index, V& v) const
23120                 {
23121                         if(index != type) {return false;} return v(ref_nested());
23122
23123                 }
23124                 private:
23125                 size_t type {0};
23126
23127         };
23128         struct Value_t : asn::typefield<true>
23129         {
23130                 ~Value_t()      {clear();}
23131                 size_t get_index() const {return type;}
23132                 E_RABs_ToBeReleased_ModReqItem& select_id_E_RABs_ToBeReleased_ModReqItem() { return set<E_RABs_ToBeReleased_ModReqItem>(1); }
23133                 E_RABs_ToBeReleased_ModReqItem const* get_id_E_RABs_ToBeReleased_ModReqItem() const { return get<E_RABs_ToBeReleased_ModReqItem>(1); }
23134                 bool is_unknown() const { return type == 2; }
23135                 void clear()
23136                 {
23137                         switch(type)
23138                         {
23139                         case 1: var.destroy<E_RABs_ToBeReleased_ModReqItem>(); break;
23140                         }
23141                         type = 0; ref_nested().clear();
23142                 }
23143                 template<typename V> static inline void enumerate(V& v)
23144                 {
23145                         v.template operator()<E_RABs_ToBeReleased_ModReqItem>(1);
23146
23147                 }
23148                 protected:
23149                 template<typename V> bool decode(size_t index, V& v)
23150                 {
23151                         clear();
23152                         switch(index)
23153                         {
23154                         case 1: v(select_id_E_RABs_ToBeReleased_ModReqItem()); return true;
23155                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
23156                         }
23157                         return false;
23158
23159                 }
23160                 template<typename V> bool encode(size_t index, V& v) const
23161                 {
23162                         if(index != type) return false;
23163                         switch(type)
23164                         {
23165                         case 1: v(var.as<E_RABs_ToBeReleased_ModReqItem>()); return true;
23166                         }
23167                         return false;
23168
23169                 }
23170                 private:
23171                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
23172                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
23173                 union union_type
23174                 {
23175                         char dummy1[sizeof(E_RABs_ToBeReleased_ModReqItem)];
23176
23177                 };
23178                 asn::variant<sizeof(union_type)> var;
23179                 size_t type {0};
23180
23181         };
23182         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
23183         {
23184                 size_t get_index() const {return type;}
23185                 bool is_unknown() const { return type == 2; }
23186                 void clear() {type = 0;}
23187                 void select_id_E_RABs_ToBeReleased_ModReqItem() { set(mandatory); type=1;}
23188                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
23189                 template<typename V>  bool decode(V& v)
23190                 {
23191                         clear();
23192                         if(!v(ref_nested())) return false;
23193                         if(equal(mandatory)) { type = 1; return true; }
23194                         else { type = 2; return true;}
23195                         return false;
23196
23197                 }
23198                 template<typename V> bool encode(V& v) const
23199                 {
23200                         return v(ref_nested());
23201
23202                 }
23203                 protected:
23204                 template<typename V>  bool decode(size_t index, V& v)
23205                 {
23206                         clear();
23207                         switch(index)
23208                         {
23209                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
23210                         case 2: type = 2; return v(ref_nested());
23211                         ref_nested().clear();
23212                         }
23213                         return false;
23214
23215                 }
23216                 template<typename V> bool encode(size_t index, V& v) const
23217                 {
23218                         if(index != type) {return false;} return v(ref_nested());
23219
23220                 }
23221                 private:
23222                 size_t type {0};
23223
23224         };
23225
23226 };
23227 /*
23228 E-RABs-ToBeReleased-List-ModReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqItemIEs} }
23229 */
23230
23231 struct E_RABs_ToBeReleased_List_ModReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>
23232 {
23233         static constexpr const char* name() {return "E_RABs_ToBeReleased_List_ModReq_elm";}
23234         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqItemIEs>;
23235
23236 };
23237 struct E_RABs_ToBeReleased_List_ModReq : asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>
23238 {
23239         static constexpr const char* name() {return "E-RABs-ToBeReleased-List-ModReq";}
23240         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_ModReq_elm>;
23241         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
23242
23243 };
23244 /*
23245 E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23246         ...
23247 }
23248 */
23249
23250 struct E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs
23251 {
23252         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23253         {
23254                 size_t get_index() const {return type;}
23255                 bool is_unknown() const { return type == 1; }
23256                 void clear() {type = 0;}
23257                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23258                 template<typename V>  bool decode(V& v)
23259                 {
23260                         clear();
23261                         if(!v(ref_nested())) return false;
23262                         { type = 1; return true;}
23263                         return false;
23264
23265                 }
23266                 template<typename V> bool encode(V& v) const
23267                 {
23268                         return v(ref_nested());
23269
23270                 }
23271                 protected:
23272                 template<typename V>  bool decode(size_t index, V& v)
23273                 {
23274                         clear();
23275                         switch(index)
23276                         {
23277                         case 1: type = 1; return v(ref_nested());
23278                         ref_nested().clear();
23279                         }
23280                         return false;
23281
23282                 }
23283                 template<typename V> bool encode(size_t index, V& v) const
23284                 {
23285                         if(index != type) {return false;} return v(ref_nested());
23286
23287                 }
23288                 private:
23289                 size_t type {0};
23290
23291         };
23292         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23293         {
23294                 size_t get_index() const {return type;}
23295                 bool is_unknown() const { return type == 1; }
23296                 void clear() {type = 0;}
23297                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23298                 template<typename V>  bool decode(V& v)
23299                 {
23300                         clear();
23301                         if(!v(ref_nested())) return false;
23302                         { type = 1; return true;}
23303                         return false;
23304
23305                 }
23306                 template<typename V> bool encode(V& v) const
23307                 {
23308                         return v(ref_nested());
23309
23310                 }
23311                 protected:
23312                 template<typename V>  bool decode(size_t index, V& v)
23313                 {
23314                         clear();
23315                         switch(index)
23316                         {
23317                         case 1: type = 1; return v(ref_nested());
23318                         ref_nested().clear();
23319                         }
23320                         return false;
23321
23322                 }
23323                 template<typename V> bool encode(size_t index, V& v) const
23324                 {
23325                         if(index != type) {return false;} return v(ref_nested());
23326
23327                 }
23328                 private:
23329                 size_t type {0};
23330
23331         };
23332         struct Extension_t : asn::typefield<true>
23333         {
23334                 ~Extension_t()  {clear();}
23335                 size_t get_index() const {return type;}
23336                 bool is_unknown() const { return type == 1; }
23337                 void clear()
23338                 {
23339                         type = 0; ref_nested().clear();
23340                 }
23341                 template<typename V> static inline void enumerate(V& v)
23342                 {
23343
23344                 }
23345                 protected:
23346                 template<typename V> bool decode(size_t index, V& v)
23347                 {
23348                         clear();
23349                         switch(index)
23350                         {
23351                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23352                         }
23353                         return false;
23354
23355                 }
23356                 template<typename V> bool encode(size_t index, V& v) const
23357                 {
23358                         if(index != type) return false;
23359                         return false;
23360
23361                 }
23362                 private:
23363                 size_t type {0};
23364
23365         };
23366         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23367         {
23368                 size_t get_index() const {return type;}
23369                 bool is_unknown() const { return type == 1; }
23370                 void clear() {type = 0;}
23371                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23372                 template<typename V>  bool decode(V& v)
23373                 {
23374                         clear();
23375                         if(!v(ref_nested())) return false;
23376                         { type = 1; return true;}
23377                         return false;
23378
23379                 }
23380                 template<typename V> bool encode(V& v) const
23381                 {
23382                         return v(ref_nested());
23383
23384                 }
23385                 protected:
23386                 template<typename V>  bool decode(size_t index, V& v)
23387                 {
23388                         clear();
23389                         switch(index)
23390                         {
23391                         case 1: type = 1; return v(ref_nested());
23392                         ref_nested().clear();
23393                         }
23394                         return false;
23395
23396                 }
23397                 template<typename V> bool encode(size_t index, V& v) const
23398                 {
23399                         if(index != type) {return false;} return v(ref_nested());
23400
23401                 }
23402                 private:
23403                 size_t type {0};
23404
23405         };
23406
23407 };
23408 /*
23409 E-RABs-ToBeReleased-RelConfItem-SCG-Bearer ::= SEQUENCE {
23410         e-RAB-ID                                                E-RAB-ID,
23411         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
23412         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
23413         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-SCG-BearerExtIEs} } OPTIONAL,
23414         ...
23415 }
23416 */
23417
23418 struct E_RABs_ToBeReleased_RelConfItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
23419 {
23420         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-SCG-Bearer";}
23421         using parent_t = asn::sequence<4, 0, true, 3>;
23422         struct e_RAB_ID_t : E_RAB_ID
23423         {
23424                 static constexpr const char* name() {return "e_RAB_ID_t";}
23425                 using parent_t = E_RAB_ID;
23426
23427         };
23428         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
23429         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
23430         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23431         {
23432                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
23433                 using parent_t = GTPtunnelEndpoint;
23434                 static constexpr bool optional = true;
23435
23436         };
23437         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
23438         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
23439         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23440         {
23441                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
23442                 using parent_t = GTPtunnelEndpoint;
23443                 static constexpr bool optional = true;
23444
23445         };
23446         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
23447         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
23448         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>
23449         {
23450                 static constexpr const char* name() {return "iE_Extensions_t";}
23451                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_SCG_BearerExtIEs>;
23452                 static constexpr bool optional = true;
23453
23454         };
23455         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23456         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23457         template<typename V> void decode(V& v)
23458         {
23459                 v(e_RAB_ID);
23460                 v(uL_Forwarding_GTPtunnelEndpoint);
23461                 v(dL_Forwarding_GTPtunnelEndpoint);
23462                 v(iE_Extensions);
23463
23464         };
23465         template<typename V> void encode(V& v) const
23466         {
23467                 v(e_RAB_ID);
23468                 v(uL_Forwarding_GTPtunnelEndpoint);
23469                 v(dL_Forwarding_GTPtunnelEndpoint);
23470                 v(iE_Extensions);
23471
23472         };
23473         void clear()
23474         {
23475                 e_RAB_ID.clear();
23476                 uL_Forwarding_GTPtunnelEndpoint.clear();
23477                 dL_Forwarding_GTPtunnelEndpoint.clear();
23478                 iE_Extensions.clear();
23479
23480         };
23481         private:
23482         e_RAB_ID_t      e_RAB_ID;
23483         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
23484         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
23485         iE_Extensions_t iE_Extensions;
23486
23487 };
23488 /*
23489 E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23490         ...
23491 }
23492 */
23493
23494 struct E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs
23495 {
23496         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23497         {
23498                 size_t get_index() const {return type;}
23499                 bool is_unknown() const { return type == 1; }
23500                 void clear() {type = 0;}
23501                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23502                 template<typename V>  bool decode(V& v)
23503                 {
23504                         clear();
23505                         if(!v(ref_nested())) return false;
23506                         { type = 1; return true;}
23507                         return false;
23508
23509                 }
23510                 template<typename V> bool encode(V& v) const
23511                 {
23512                         return v(ref_nested());
23513
23514                 }
23515                 protected:
23516                 template<typename V>  bool decode(size_t index, V& v)
23517                 {
23518                         clear();
23519                         switch(index)
23520                         {
23521                         case 1: type = 1; return v(ref_nested());
23522                         ref_nested().clear();
23523                         }
23524                         return false;
23525
23526                 }
23527                 template<typename V> bool encode(size_t index, V& v) const
23528                 {
23529                         if(index != type) {return false;} return v(ref_nested());
23530
23531                 }
23532                 private:
23533                 size_t type {0};
23534
23535         };
23536         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23537         {
23538                 size_t get_index() const {return type;}
23539                 bool is_unknown() const { return type == 1; }
23540                 void clear() {type = 0;}
23541                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23542                 template<typename V>  bool decode(V& v)
23543                 {
23544                         clear();
23545                         if(!v(ref_nested())) return false;
23546                         { type = 1; return true;}
23547                         return false;
23548
23549                 }
23550                 template<typename V> bool encode(V& v) const
23551                 {
23552                         return v(ref_nested());
23553
23554                 }
23555                 protected:
23556                 template<typename V>  bool decode(size_t index, V& v)
23557                 {
23558                         clear();
23559                         switch(index)
23560                         {
23561                         case 1: type = 1; return v(ref_nested());
23562                         ref_nested().clear();
23563                         }
23564                         return false;
23565
23566                 }
23567                 template<typename V> bool encode(size_t index, V& v) const
23568                 {
23569                         if(index != type) {return false;} return v(ref_nested());
23570
23571                 }
23572                 private:
23573                 size_t type {0};
23574
23575         };
23576         struct Extension_t : asn::typefield<true>
23577         {
23578                 ~Extension_t()  {clear();}
23579                 size_t get_index() const {return type;}
23580                 bool is_unknown() const { return type == 1; }
23581                 void clear()
23582                 {
23583                         type = 0; ref_nested().clear();
23584                 }
23585                 template<typename V> static inline void enumerate(V& v)
23586                 {
23587
23588                 }
23589                 protected:
23590                 template<typename V> bool decode(size_t index, V& v)
23591                 {
23592                         clear();
23593                         switch(index)
23594                         {
23595                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23596                         }
23597                         return false;
23598
23599                 }
23600                 template<typename V> bool encode(size_t index, V& v) const
23601                 {
23602                         if(index != type) return false;
23603                         return false;
23604
23605                 }
23606                 private:
23607                 size_t type {0};
23608
23609         };
23610         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23611         {
23612                 size_t get_index() const {return type;}
23613                 bool is_unknown() const { return type == 1; }
23614                 void clear() {type = 0;}
23615                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23616                 template<typename V>  bool decode(V& v)
23617                 {
23618                         clear();
23619                         if(!v(ref_nested())) return false;
23620                         { type = 1; return true;}
23621                         return false;
23622
23623                 }
23624                 template<typename V> bool encode(V& v) const
23625                 {
23626                         return v(ref_nested());
23627
23628                 }
23629                 protected:
23630                 template<typename V>  bool decode(size_t index, V& v)
23631                 {
23632                         clear();
23633                         switch(index)
23634                         {
23635                         case 1: type = 1; return v(ref_nested());
23636                         ref_nested().clear();
23637                         }
23638                         return false;
23639
23640                 }
23641                 template<typename V> bool encode(size_t index, V& v) const
23642                 {
23643                         if(index != type) {return false;} return v(ref_nested());
23644
23645                 }
23646                 private:
23647                 size_t type {0};
23648
23649         };
23650
23651 };
23652 /*
23653 E-RABs-ToBeReleased-RelConfItem-Split-Bearer ::= SEQUENCE {
23654         e-RAB-ID                                                E-RAB-ID,
23655         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                       OPTIONAL,
23656         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelConfItem-Split-BearerExtIEs} } OPTIONAL,
23657         ...
23658 }
23659 */
23660
23661 struct E_RABs_ToBeReleased_RelConfItem_Split_Bearer : asn::sequence<3, 0, true, 2>
23662 {
23663         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem-Split-Bearer";}
23664         using parent_t = asn::sequence<3, 0, true, 2>;
23665         struct e_RAB_ID_t : E_RAB_ID
23666         {
23667                 static constexpr const char* name() {return "e_RAB_ID_t";}
23668                 using parent_t = E_RAB_ID;
23669
23670         };
23671         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
23672         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
23673         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
23674         {
23675                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
23676                 using parent_t = GTPtunnelEndpoint;
23677                 static constexpr bool optional = true;
23678
23679         };
23680         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
23681         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
23682         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>
23683         {
23684                 static constexpr const char* name() {return "iE_Extensions_t";}
23685                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelConfItem_Split_BearerExtIEs>;
23686                 static constexpr bool optional = true;
23687
23688         };
23689         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23690         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23691         template<typename V> void decode(V& v)
23692         {
23693                 v(e_RAB_ID);
23694                 v(dL_Forwarding_GTPtunnelEndpoint);
23695                 v(iE_Extensions);
23696
23697         };
23698         template<typename V> void encode(V& v) const
23699         {
23700                 v(e_RAB_ID);
23701                 v(dL_Forwarding_GTPtunnelEndpoint);
23702                 v(iE_Extensions);
23703
23704         };
23705         void clear()
23706         {
23707                 e_RAB_ID.clear();
23708                 dL_Forwarding_GTPtunnelEndpoint.clear();
23709                 iE_Extensions.clear();
23710
23711         };
23712         private:
23713         e_RAB_ID_t      e_RAB_ID;
23714         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
23715         iE_Extensions_t iE_Extensions;
23716
23717 };
23718 /*
23719 E-RABs-ToBeReleased-RelConfItem ::= CHOICE {
23720         sCG-Bearer              E-RABs-ToBeReleased-RelConfItem-SCG-Bearer,
23721         split-Bearer    E-RABs-ToBeReleased-RelConfItem-Split-Bearer,
23722         ...
23723 }
23724 */
23725
23726 struct E_RABs_ToBeReleased_RelConfItem : asn::choice<2, 0, true>
23727 {
23728         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelConfItem";}
23729         using parent_t = asn::choice<2, 0, true>;
23730         index_type get_index() const {return index;}
23731         bool is_unknown() const {return index == 3;}
23732         void set_unknown() { set_index(3);  }
23733         ~E_RABs_ToBeReleased_RelConfItem() {clear();}
23734         struct sCG_Bearer_t : E_RABs_ToBeReleased_RelConfItem_SCG_Bearer
23735         {
23736                 static constexpr const char* name() {return "sCG_Bearer_t";}
23737                 using parent_t = E_RABs_ToBeReleased_RelConfItem_SCG_Bearer;
23738
23739         };
23740         struct split_Bearer_t : E_RABs_ToBeReleased_RelConfItem_Split_Bearer
23741         {
23742                 static constexpr const char* name() {return "split_Bearer_t";}
23743                 using parent_t = E_RABs_ToBeReleased_RelConfItem_Split_Bearer;
23744
23745         };
23746         void clear()
23747         {
23748                 switch(get_index())
23749                 {
23750                 case 1: var.destroy<sCG_Bearer_t>(); break;
23751                 case 2: var.destroy<split_Bearer_t>(); break;
23752                 }
23753                 index = 0;
23754                 base::clear();
23755         }
23756         template<typename V> bool decode(size_t idx, V& v)
23757         {
23758                 clear();
23759                 switch(idx)
23760                 {
23761                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
23762                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
23763                 }
23764                 return false;
23765
23766         }
23767         template<typename V> bool encode(V& v) const
23768         {
23769                 switch(get_index())
23770                 {
23771                 case 1: return v(var.as<sCG_Bearer_t>());
23772                 case 2: return v(var.as<split_Bearer_t>());
23773                 }
23774                 return false;
23775         }
23776         template<typename V> static inline void enumerate(V& v)
23777         {
23778                 v.template operator()<sCG_Bearer_t>(1);
23779                 v.template operator()<split_Bearer_t>(2);
23780
23781         }
23782         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
23783         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
23784         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
23785         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
23786         private:
23787         void set_index(index_type i) {index = i; base::set();}
23788         union union_type
23789         {
23790                 char dummy1[sizeof(sCG_Bearer_t)];
23791                 char dummy2[sizeof(split_Bearer_t)];
23792
23793         };
23794         asn::variant<sizeof(union_type)>        var;
23795         index_type      index {0};
23796 };
23797 /*
23798 E-RABs-ToBeReleased-RelConfItemIEs X2AP-PROTOCOL-IES ::= {
23799         { ID id-E-RABs-ToBeReleased-RelConfItem         CRITICALITY ignore              TYPE E-RABs-ToBeReleased-RelConfItem            PRESENCE mandatory},
23800         ...
23801 }
23802 */
23803
23804 struct E_RABs_ToBeReleased_RelConfItemIEs
23805 {
23806         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
23807         {
23808                 size_t get_index() const {return type;}
23809                 bool is_unknown() const { return type == 2; }
23810                 void clear() {type = 0;}
23811                 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(id_E_RABs_ToBeReleased_RelConfItem); type=1;}
23812                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
23813                 template<typename V>  bool decode(V& v)
23814                 {
23815                         clear();
23816                         if(!v(ref_nested())) return false;
23817                         if(equal(id_E_RABs_ToBeReleased_RelConfItem)) { type = 1; return true; }
23818                         else { type = 2; return true;}
23819                         return false;
23820
23821                 }
23822                 template<typename V> bool encode(V& v) const
23823                 {
23824                         return v(ref_nested());
23825
23826                 }
23827                 protected:
23828                 template<typename V>  bool decode(size_t index, V& v)
23829                 {
23830                         clear();
23831                         switch(index)
23832                         {
23833                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_RelConfItem);} return false;
23834                         case 2: type = 2; return v(ref_nested());
23835                         ref_nested().clear();
23836                         }
23837                         return false;
23838
23839                 }
23840                 template<typename V> bool encode(size_t index, V& v) const
23841                 {
23842                         if(index != type) {return false;} return v(ref_nested());
23843
23844                 }
23845                 private:
23846                 size_t type {0};
23847
23848         };
23849         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
23850         {
23851                 size_t get_index() const {return type;}
23852                 bool is_unknown() const { return type == 2; }
23853                 void clear() {type = 0;}
23854                 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(ignore); type=1;}
23855                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
23856                 template<typename V>  bool decode(V& v)
23857                 {
23858                         clear();
23859                         if(!v(ref_nested())) return false;
23860                         if(equal(ignore)) { type = 1; return true; }
23861                         else { type = 2; return true;}
23862                         return false;
23863
23864                 }
23865                 template<typename V> bool encode(V& v) const
23866                 {
23867                         return v(ref_nested());
23868
23869                 }
23870                 protected:
23871                 template<typename V>  bool decode(size_t index, V& v)
23872                 {
23873                         clear();
23874                         switch(index)
23875                         {
23876                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
23877                         case 2: type = 2; return v(ref_nested());
23878                         ref_nested().clear();
23879                         }
23880                         return false;
23881
23882                 }
23883                 template<typename V> bool encode(size_t index, V& v) const
23884                 {
23885                         if(index != type) {return false;} return v(ref_nested());
23886
23887                 }
23888                 private:
23889                 size_t type {0};
23890
23891         };
23892         struct Value_t : asn::typefield<true>
23893         {
23894                 ~Value_t()      {clear();}
23895                 size_t get_index() const {return type;}
23896                 E_RABs_ToBeReleased_RelConfItem& select_id_E_RABs_ToBeReleased_RelConfItem() { return set<E_RABs_ToBeReleased_RelConfItem>(1); }
23897                 E_RABs_ToBeReleased_RelConfItem const* get_id_E_RABs_ToBeReleased_RelConfItem() const { return get<E_RABs_ToBeReleased_RelConfItem>(1); }
23898                 bool is_unknown() const { return type == 2; }
23899                 void clear()
23900                 {
23901                         switch(type)
23902                         {
23903                         case 1: var.destroy<E_RABs_ToBeReleased_RelConfItem>(); break;
23904                         }
23905                         type = 0; ref_nested().clear();
23906                 }
23907                 template<typename V> static inline void enumerate(V& v)
23908                 {
23909                         v.template operator()<E_RABs_ToBeReleased_RelConfItem>(1);
23910
23911                 }
23912                 protected:
23913                 template<typename V> bool decode(size_t index, V& v)
23914                 {
23915                         clear();
23916                         switch(index)
23917                         {
23918                         case 1: v(select_id_E_RABs_ToBeReleased_RelConfItem()); return true;
23919                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
23920                         }
23921                         return false;
23922
23923                 }
23924                 template<typename V> bool encode(size_t index, V& v) const
23925                 {
23926                         if(index != type) return false;
23927                         switch(type)
23928                         {
23929                         case 1: v(var.as<E_RABs_ToBeReleased_RelConfItem>()); return true;
23930                         }
23931                         return false;
23932
23933                 }
23934                 private:
23935                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
23936                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
23937                 union union_type
23938                 {
23939                         char dummy1[sizeof(E_RABs_ToBeReleased_RelConfItem)];
23940
23941                 };
23942                 asn::variant<sizeof(union_type)> var;
23943                 size_t type {0};
23944
23945         };
23946         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
23947         {
23948                 size_t get_index() const {return type;}
23949                 bool is_unknown() const { return type == 2; }
23950                 void clear() {type = 0;}
23951                 void select_id_E_RABs_ToBeReleased_RelConfItem() { set(mandatory); type=1;}
23952                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
23953                 template<typename V>  bool decode(V& v)
23954                 {
23955                         clear();
23956                         if(!v(ref_nested())) return false;
23957                         if(equal(mandatory)) { type = 1; return true; }
23958                         else { type = 2; return true;}
23959                         return false;
23960
23961                 }
23962                 template<typename V> bool encode(V& v) const
23963                 {
23964                         return v(ref_nested());
23965
23966                 }
23967                 protected:
23968                 template<typename V>  bool decode(size_t index, V& v)
23969                 {
23970                         clear();
23971                         switch(index)
23972                         {
23973                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
23974                         case 2: type = 2; return v(ref_nested());
23975                         ref_nested().clear();
23976                         }
23977                         return false;
23978
23979                 }
23980                 template<typename V> bool encode(size_t index, V& v) const
23981                 {
23982                         if(index != type) {return false;} return v(ref_nested());
23983
23984                 }
23985                 private:
23986                 size_t type {0};
23987
23988         };
23989
23990 };
23991 /*
23992 E-RABs-ToBeReleased-List-RelConf ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelConfItemIEs} }
23993 */
23994
23995 struct E_RABs_ToBeReleased_List_RelConf_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>
23996 {
23997         static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelConf_elm";}
23998         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelConfItemIEs>;
23999
24000 };
24001 struct E_RABs_ToBeReleased_List_RelConf : asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>
24002 {
24003         static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelConf";}
24004         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelConf_elm>;
24005         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
24006
24007 };
24008 /*
24009 E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24010         ...
24011 }
24012 */
24013
24014 struct E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs
24015 {
24016         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24017         {
24018                 size_t get_index() const {return type;}
24019                 bool is_unknown() const { return type == 1; }
24020                 void clear() {type = 0;}
24021                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24022                 template<typename V>  bool decode(V& v)
24023                 {
24024                         clear();
24025                         if(!v(ref_nested())) return false;
24026                         { type = 1; return true;}
24027                         return false;
24028
24029                 }
24030                 template<typename V> bool encode(V& v) const
24031                 {
24032                         return v(ref_nested());
24033
24034                 }
24035                 protected:
24036                 template<typename V>  bool decode(size_t index, V& v)
24037                 {
24038                         clear();
24039                         switch(index)
24040                         {
24041                         case 1: type = 1; return v(ref_nested());
24042                         ref_nested().clear();
24043                         }
24044                         return false;
24045
24046                 }
24047                 template<typename V> bool encode(size_t index, V& v) const
24048                 {
24049                         if(index != type) {return false;} return v(ref_nested());
24050
24051                 }
24052                 private:
24053                 size_t type {0};
24054
24055         };
24056         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24057         {
24058                 size_t get_index() const {return type;}
24059                 bool is_unknown() const { return type == 1; }
24060                 void clear() {type = 0;}
24061                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24062                 template<typename V>  bool decode(V& v)
24063                 {
24064                         clear();
24065                         if(!v(ref_nested())) return false;
24066                         { type = 1; return true;}
24067                         return false;
24068
24069                 }
24070                 template<typename V> bool encode(V& v) const
24071                 {
24072                         return v(ref_nested());
24073
24074                 }
24075                 protected:
24076                 template<typename V>  bool decode(size_t index, V& v)
24077                 {
24078                         clear();
24079                         switch(index)
24080                         {
24081                         case 1: type = 1; return v(ref_nested());
24082                         ref_nested().clear();
24083                         }
24084                         return false;
24085
24086                 }
24087                 template<typename V> bool encode(size_t index, V& v) const
24088                 {
24089                         if(index != type) {return false;} return v(ref_nested());
24090
24091                 }
24092                 private:
24093                 size_t type {0};
24094
24095         };
24096         struct Extension_t : asn::typefield<true>
24097         {
24098                 ~Extension_t()  {clear();}
24099                 size_t get_index() const {return type;}
24100                 bool is_unknown() const { return type == 1; }
24101                 void clear()
24102                 {
24103                         type = 0; ref_nested().clear();
24104                 }
24105                 template<typename V> static inline void enumerate(V& v)
24106                 {
24107
24108                 }
24109                 protected:
24110                 template<typename V> bool decode(size_t index, V& v)
24111                 {
24112                         clear();
24113                         switch(index)
24114                         {
24115                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24116                         }
24117                         return false;
24118
24119                 }
24120                 template<typename V> bool encode(size_t index, V& v) const
24121                 {
24122                         if(index != type) return false;
24123                         return false;
24124
24125                 }
24126                 private:
24127                 size_t type {0};
24128
24129         };
24130         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24131         {
24132                 size_t get_index() const {return type;}
24133                 bool is_unknown() const { return type == 1; }
24134                 void clear() {type = 0;}
24135                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24136                 template<typename V>  bool decode(V& v)
24137                 {
24138                         clear();
24139                         if(!v(ref_nested())) return false;
24140                         { type = 1; return true;}
24141                         return false;
24142
24143                 }
24144                 template<typename V> bool encode(V& v) const
24145                 {
24146                         return v(ref_nested());
24147
24148                 }
24149                 protected:
24150                 template<typename V>  bool decode(size_t index, V& v)
24151                 {
24152                         clear();
24153                         switch(index)
24154                         {
24155                         case 1: type = 1; return v(ref_nested());
24156                         ref_nested().clear();
24157                         }
24158                         return false;
24159
24160                 }
24161                 template<typename V> bool encode(size_t index, V& v) const
24162                 {
24163                         if(index != type) {return false;} return v(ref_nested());
24164
24165                 }
24166                 private:
24167                 size_t type {0};
24168
24169         };
24170
24171 };
24172 /*
24173 E-RABs-ToBeReleased-RelReqItem-SCG-Bearer ::= SEQUENCE {
24174         e-RAB-ID                                                E-RAB-ID,
24175         uL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
24176         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                               OPTIONAL,
24177         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-SCG-BearerExtIEs} } OPTIONAL,
24178         ...
24179 }
24180 */
24181
24182 struct E_RABs_ToBeReleased_RelReqItem_SCG_Bearer : asn::sequence<4, 0, true, 3>
24183 {
24184         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-SCG-Bearer";}
24185         using parent_t = asn::sequence<4, 0, true, 3>;
24186         struct e_RAB_ID_t : E_RAB_ID
24187         {
24188                 static constexpr const char* name() {return "e_RAB_ID_t";}
24189                 using parent_t = E_RAB_ID;
24190
24191         };
24192         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24193         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24194         struct uL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24195         {
24196                 static constexpr const char* name() {return "uL_Forwarding_GTPtunnelEndpoint_t";}
24197                 using parent_t = GTPtunnelEndpoint;
24198                 static constexpr bool optional = true;
24199
24200         };
24201         uL_Forwarding_GTPtunnelEndpoint_t& set_uL_Forwarding_GTPtunnelEndpoint() { uL_Forwarding_GTPtunnelEndpoint.setpresent(true); return uL_Forwarding_GTPtunnelEndpoint;}
24202         uL_Forwarding_GTPtunnelEndpoint_t const* get_uL_Forwarding_GTPtunnelEndpoint() const {return uL_Forwarding_GTPtunnelEndpoint.is_valid() ? &uL_Forwarding_GTPtunnelEndpoint : nullptr;}
24203         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24204         {
24205                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
24206                 using parent_t = GTPtunnelEndpoint;
24207                 static constexpr bool optional = true;
24208
24209         };
24210         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
24211         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
24212         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>
24213         {
24214                 static constexpr const char* name() {return "iE_Extensions_t";}
24215                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_SCG_BearerExtIEs>;
24216                 static constexpr bool optional = true;
24217
24218         };
24219         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24220         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24221         template<typename V> void decode(V& v)
24222         {
24223                 v(e_RAB_ID);
24224                 v(uL_Forwarding_GTPtunnelEndpoint);
24225                 v(dL_Forwarding_GTPtunnelEndpoint);
24226                 v(iE_Extensions);
24227
24228         };
24229         template<typename V> void encode(V& v) const
24230         {
24231                 v(e_RAB_ID);
24232                 v(uL_Forwarding_GTPtunnelEndpoint);
24233                 v(dL_Forwarding_GTPtunnelEndpoint);
24234                 v(iE_Extensions);
24235
24236         };
24237         void clear()
24238         {
24239                 e_RAB_ID.clear();
24240                 uL_Forwarding_GTPtunnelEndpoint.clear();
24241                 dL_Forwarding_GTPtunnelEndpoint.clear();
24242                 iE_Extensions.clear();
24243
24244         };
24245         private:
24246         e_RAB_ID_t      e_RAB_ID;
24247         uL_Forwarding_GTPtunnelEndpoint_t       uL_Forwarding_GTPtunnelEndpoint;
24248         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
24249         iE_Extensions_t iE_Extensions;
24250
24251 };
24252 /*
24253 E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24254         ...
24255 }
24256 */
24257
24258 struct E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs
24259 {
24260         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24261         {
24262                 size_t get_index() const {return type;}
24263                 bool is_unknown() const { return type == 1; }
24264                 void clear() {type = 0;}
24265                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24266                 template<typename V>  bool decode(V& v)
24267                 {
24268                         clear();
24269                         if(!v(ref_nested())) return false;
24270                         { type = 1; return true;}
24271                         return false;
24272
24273                 }
24274                 template<typename V> bool encode(V& v) const
24275                 {
24276                         return v(ref_nested());
24277
24278                 }
24279                 protected:
24280                 template<typename V>  bool decode(size_t index, V& v)
24281                 {
24282                         clear();
24283                         switch(index)
24284                         {
24285                         case 1: type = 1; return v(ref_nested());
24286                         ref_nested().clear();
24287                         }
24288                         return false;
24289
24290                 }
24291                 template<typename V> bool encode(size_t index, V& v) const
24292                 {
24293                         if(index != type) {return false;} return v(ref_nested());
24294
24295                 }
24296                 private:
24297                 size_t type {0};
24298
24299         };
24300         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24301         {
24302                 size_t get_index() const {return type;}
24303                 bool is_unknown() const { return type == 1; }
24304                 void clear() {type = 0;}
24305                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24306                 template<typename V>  bool decode(V& v)
24307                 {
24308                         clear();
24309                         if(!v(ref_nested())) return false;
24310                         { type = 1; return true;}
24311                         return false;
24312
24313                 }
24314                 template<typename V> bool encode(V& v) const
24315                 {
24316                         return v(ref_nested());
24317
24318                 }
24319                 protected:
24320                 template<typename V>  bool decode(size_t index, V& v)
24321                 {
24322                         clear();
24323                         switch(index)
24324                         {
24325                         case 1: type = 1; return v(ref_nested());
24326                         ref_nested().clear();
24327                         }
24328                         return false;
24329
24330                 }
24331                 template<typename V> bool encode(size_t index, V& v) const
24332                 {
24333                         if(index != type) {return false;} return v(ref_nested());
24334
24335                 }
24336                 private:
24337                 size_t type {0};
24338
24339         };
24340         struct Extension_t : asn::typefield<true>
24341         {
24342                 ~Extension_t()  {clear();}
24343                 size_t get_index() const {return type;}
24344                 bool is_unknown() const { return type == 1; }
24345                 void clear()
24346                 {
24347                         type = 0; ref_nested().clear();
24348                 }
24349                 template<typename V> static inline void enumerate(V& v)
24350                 {
24351
24352                 }
24353                 protected:
24354                 template<typename V> bool decode(size_t index, V& v)
24355                 {
24356                         clear();
24357                         switch(index)
24358                         {
24359                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24360                         }
24361                         return false;
24362
24363                 }
24364                 template<typename V> bool encode(size_t index, V& v) const
24365                 {
24366                         if(index != type) return false;
24367                         return false;
24368
24369                 }
24370                 private:
24371                 size_t type {0};
24372
24373         };
24374         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24375         {
24376                 size_t get_index() const {return type;}
24377                 bool is_unknown() const { return type == 1; }
24378                 void clear() {type = 0;}
24379                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24380                 template<typename V>  bool decode(V& v)
24381                 {
24382                         clear();
24383                         if(!v(ref_nested())) return false;
24384                         { type = 1; return true;}
24385                         return false;
24386
24387                 }
24388                 template<typename V> bool encode(V& v) const
24389                 {
24390                         return v(ref_nested());
24391
24392                 }
24393                 protected:
24394                 template<typename V>  bool decode(size_t index, V& v)
24395                 {
24396                         clear();
24397                         switch(index)
24398                         {
24399                         case 1: type = 1; return v(ref_nested());
24400                         ref_nested().clear();
24401                         }
24402                         return false;
24403
24404                 }
24405                 template<typename V> bool encode(size_t index, V& v) const
24406                 {
24407                         if(index != type) {return false;} return v(ref_nested());
24408
24409                 }
24410                 private:
24411                 size_t type {0};
24412
24413         };
24414
24415 };
24416 /*
24417 E-RABs-ToBeReleased-RelReqItem-Split-Bearer ::= SEQUENCE {
24418         e-RAB-ID                                                E-RAB-ID,
24419         dL-Forwarding-GTPtunnelEndpoint                 GTPtunnelEndpoint                                                                                                       OPTIONAL,
24420         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-RelReqItem-Split-BearerExtIEs} } OPTIONAL,
24421         ...
24422 }
24423 */
24424
24425 struct E_RABs_ToBeReleased_RelReqItem_Split_Bearer : asn::sequence<3, 0, true, 2>
24426 {
24427         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem-Split-Bearer";}
24428         using parent_t = asn::sequence<3, 0, true, 2>;
24429         struct e_RAB_ID_t : E_RAB_ID
24430         {
24431                 static constexpr const char* name() {return "e_RAB_ID_t";}
24432                 using parent_t = E_RAB_ID;
24433
24434         };
24435         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24436         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24437         struct dL_Forwarding_GTPtunnelEndpoint_t : GTPtunnelEndpoint
24438         {
24439                 static constexpr const char* name() {return "dL_Forwarding_GTPtunnelEndpoint_t";}
24440                 using parent_t = GTPtunnelEndpoint;
24441                 static constexpr bool optional = true;
24442
24443         };
24444         dL_Forwarding_GTPtunnelEndpoint_t& set_dL_Forwarding_GTPtunnelEndpoint() { dL_Forwarding_GTPtunnelEndpoint.setpresent(true); return dL_Forwarding_GTPtunnelEndpoint;}
24445         dL_Forwarding_GTPtunnelEndpoint_t const* get_dL_Forwarding_GTPtunnelEndpoint() const {return dL_Forwarding_GTPtunnelEndpoint.is_valid() ? &dL_Forwarding_GTPtunnelEndpoint : nullptr;}
24446         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>
24447         {
24448                 static constexpr const char* name() {return "iE_Extensions_t";}
24449                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_RelReqItem_Split_BearerExtIEs>;
24450                 static constexpr bool optional = true;
24451
24452         };
24453         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24454         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24455         template<typename V> void decode(V& v)
24456         {
24457                 v(e_RAB_ID);
24458                 v(dL_Forwarding_GTPtunnelEndpoint);
24459                 v(iE_Extensions);
24460
24461         };
24462         template<typename V> void encode(V& v) const
24463         {
24464                 v(e_RAB_ID);
24465                 v(dL_Forwarding_GTPtunnelEndpoint);
24466                 v(iE_Extensions);
24467
24468         };
24469         void clear()
24470         {
24471                 e_RAB_ID.clear();
24472                 dL_Forwarding_GTPtunnelEndpoint.clear();
24473                 iE_Extensions.clear();
24474
24475         };
24476         private:
24477         e_RAB_ID_t      e_RAB_ID;
24478         dL_Forwarding_GTPtunnelEndpoint_t       dL_Forwarding_GTPtunnelEndpoint;
24479         iE_Extensions_t iE_Extensions;
24480
24481 };
24482 /*
24483 E-RABs-ToBeReleased-RelReqItem ::= CHOICE {
24484         sCG-Bearer              E-RABs-ToBeReleased-RelReqItem-SCG-Bearer,
24485         split-Bearer    E-RABs-ToBeReleased-RelReqItem-Split-Bearer,
24486         ...
24487 }
24488 */
24489
24490 struct E_RABs_ToBeReleased_RelReqItem : asn::choice<2, 0, true>
24491 {
24492         static constexpr const char* name() {return "E-RABs-ToBeReleased-RelReqItem";}
24493         using parent_t = asn::choice<2, 0, true>;
24494         index_type get_index() const {return index;}
24495         bool is_unknown() const {return index == 3;}
24496         void set_unknown() { set_index(3);  }
24497         ~E_RABs_ToBeReleased_RelReqItem() {clear();}
24498         struct sCG_Bearer_t : E_RABs_ToBeReleased_RelReqItem_SCG_Bearer
24499         {
24500                 static constexpr const char* name() {return "sCG_Bearer_t";}
24501                 using parent_t = E_RABs_ToBeReleased_RelReqItem_SCG_Bearer;
24502
24503         };
24504         struct split_Bearer_t : E_RABs_ToBeReleased_RelReqItem_Split_Bearer
24505         {
24506                 static constexpr const char* name() {return "split_Bearer_t";}
24507                 using parent_t = E_RABs_ToBeReleased_RelReqItem_Split_Bearer;
24508
24509         };
24510         void clear()
24511         {
24512                 switch(get_index())
24513                 {
24514                 case 1: var.destroy<sCG_Bearer_t>(); break;
24515                 case 2: var.destroy<split_Bearer_t>(); break;
24516                 }
24517                 index = 0;
24518                 base::clear();
24519         }
24520         template<typename V> bool decode(size_t idx, V& v)
24521         {
24522                 clear();
24523                 switch(idx)
24524                 {
24525                 case 1: set_index(1); return v(var.build<sCG_Bearer_t>());
24526                 case 2: set_index(2); return v(var.build<split_Bearer_t>());
24527                 }
24528                 return false;
24529
24530         }
24531         template<typename V> bool encode(V& v) const
24532         {
24533                 switch(get_index())
24534                 {
24535                 case 1: return v(var.as<sCG_Bearer_t>());
24536                 case 2: return v(var.as<split_Bearer_t>());
24537                 }
24538                 return false;
24539         }
24540         template<typename V> static inline void enumerate(V& v)
24541         {
24542                 v.template operator()<sCG_Bearer_t>(1);
24543                 v.template operator()<split_Bearer_t>(2);
24544
24545         }
24546         sCG_Bearer_t& select_sCG_Bearer() { if(get_index() != 1) { clear(); set_index(1); return var.build<sCG_Bearer_t>();} return var.as<sCG_Bearer_t>();}
24547         sCG_Bearer_t const* get_sCG_Bearer() const { if(get_index() == 1) { return &var.as<sCG_Bearer_t>();} return nullptr; }
24548         split_Bearer_t& select_split_Bearer() { if(get_index() != 2) { clear(); set_index(2); return var.build<split_Bearer_t>();} return var.as<split_Bearer_t>();}
24549         split_Bearer_t const* get_split_Bearer() const { if(get_index() == 2) { return &var.as<split_Bearer_t>();} return nullptr; }
24550         private:
24551         void set_index(index_type i) {index = i; base::set();}
24552         union union_type
24553         {
24554                 char dummy1[sizeof(sCG_Bearer_t)];
24555                 char dummy2[sizeof(split_Bearer_t)];
24556
24557         };
24558         asn::variant<sizeof(union_type)>        var;
24559         index_type      index {0};
24560 };
24561 /*
24562 E-RABs-ToBeReleased-RelReqItemIEs X2AP-PROTOCOL-IES ::= {
24563         { ID id-E-RABs-ToBeReleased-RelReqItem          CRITICALITY ignore      TYPE E-RABs-ToBeReleased-RelReqItem             PRESENCE mandatory},
24564         ...
24565 }
24566 */
24567
24568 struct E_RABs_ToBeReleased_RelReqItemIEs
24569 {
24570         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
24571         {
24572                 size_t get_index() const {return type;}
24573                 bool is_unknown() const { return type == 2; }
24574                 void clear() {type = 0;}
24575                 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(id_E_RABs_ToBeReleased_RelReqItem); type=1;}
24576                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
24577                 template<typename V>  bool decode(V& v)
24578                 {
24579                         clear();
24580                         if(!v(ref_nested())) return false;
24581                         if(equal(id_E_RABs_ToBeReleased_RelReqItem)) { type = 1; return true; }
24582                         else { type = 2; return true;}
24583                         return false;
24584
24585                 }
24586                 template<typename V> bool encode(V& v) const
24587                 {
24588                         return v(ref_nested());
24589
24590                 }
24591                 protected:
24592                 template<typename V>  bool decode(size_t index, V& v)
24593                 {
24594                         clear();
24595                         switch(index)
24596                         {
24597                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_RelReqItem);} return false;
24598                         case 2: type = 2; return v(ref_nested());
24599                         ref_nested().clear();
24600                         }
24601                         return false;
24602
24603                 }
24604                 template<typename V> bool encode(size_t index, V& v) const
24605                 {
24606                         if(index != type) {return false;} return v(ref_nested());
24607
24608                 }
24609                 private:
24610                 size_t type {0};
24611
24612         };
24613         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
24614         {
24615                 size_t get_index() const {return type;}
24616                 bool is_unknown() const { return type == 2; }
24617                 void clear() {type = 0;}
24618                 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(ignore); type=1;}
24619                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
24620                 template<typename V>  bool decode(V& v)
24621                 {
24622                         clear();
24623                         if(!v(ref_nested())) return false;
24624                         if(equal(ignore)) { type = 1; return true; }
24625                         else { type = 2; return true;}
24626                         return false;
24627
24628                 }
24629                 template<typename V> bool encode(V& v) const
24630                 {
24631                         return v(ref_nested());
24632
24633                 }
24634                 protected:
24635                 template<typename V>  bool decode(size_t index, V& v)
24636                 {
24637                         clear();
24638                         switch(index)
24639                         {
24640                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
24641                         case 2: type = 2; return v(ref_nested());
24642                         ref_nested().clear();
24643                         }
24644                         return false;
24645
24646                 }
24647                 template<typename V> bool encode(size_t index, V& v) const
24648                 {
24649                         if(index != type) {return false;} return v(ref_nested());
24650
24651                 }
24652                 private:
24653                 size_t type {0};
24654
24655         };
24656         struct Value_t : asn::typefield<true>
24657         {
24658                 ~Value_t()      {clear();}
24659                 size_t get_index() const {return type;}
24660                 E_RABs_ToBeReleased_RelReqItem& select_id_E_RABs_ToBeReleased_RelReqItem() { return set<E_RABs_ToBeReleased_RelReqItem>(1); }
24661                 E_RABs_ToBeReleased_RelReqItem const* get_id_E_RABs_ToBeReleased_RelReqItem() const { return get<E_RABs_ToBeReleased_RelReqItem>(1); }
24662                 bool is_unknown() const { return type == 2; }
24663                 void clear()
24664                 {
24665                         switch(type)
24666                         {
24667                         case 1: var.destroy<E_RABs_ToBeReleased_RelReqItem>(); break;
24668                         }
24669                         type = 0; ref_nested().clear();
24670                 }
24671                 template<typename V> static inline void enumerate(V& v)
24672                 {
24673                         v.template operator()<E_RABs_ToBeReleased_RelReqItem>(1);
24674
24675                 }
24676                 protected:
24677                 template<typename V> bool decode(size_t index, V& v)
24678                 {
24679                         clear();
24680                         switch(index)
24681                         {
24682                         case 1: v(select_id_E_RABs_ToBeReleased_RelReqItem()); return true;
24683                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
24684                         }
24685                         return false;
24686
24687                 }
24688                 template<typename V> bool encode(size_t index, V& v) const
24689                 {
24690                         if(index != type) return false;
24691                         switch(type)
24692                         {
24693                         case 1: v(var.as<E_RABs_ToBeReleased_RelReqItem>()); return true;
24694                         }
24695                         return false;
24696
24697                 }
24698                 private:
24699                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
24700                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
24701                 union union_type
24702                 {
24703                         char dummy1[sizeof(E_RABs_ToBeReleased_RelReqItem)];
24704
24705                 };
24706                 asn::variant<sizeof(union_type)> var;
24707                 size_t type {0};
24708
24709         };
24710         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
24711         {
24712                 size_t get_index() const {return type;}
24713                 bool is_unknown() const { return type == 2; }
24714                 void clear() {type = 0;}
24715                 void select_id_E_RABs_ToBeReleased_RelReqItem() { set(mandatory); type=1;}
24716                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
24717                 template<typename V>  bool decode(V& v)
24718                 {
24719                         clear();
24720                         if(!v(ref_nested())) return false;
24721                         if(equal(mandatory)) { type = 1; return true; }
24722                         else { type = 2; return true;}
24723                         return false;
24724
24725                 }
24726                 template<typename V> bool encode(V& v) const
24727                 {
24728                         return v(ref_nested());
24729
24730                 }
24731                 protected:
24732                 template<typename V>  bool decode(size_t index, V& v)
24733                 {
24734                         clear();
24735                         switch(index)
24736                         {
24737                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
24738                         case 2: type = 2; return v(ref_nested());
24739                         ref_nested().clear();
24740                         }
24741                         return false;
24742
24743                 }
24744                 template<typename V> bool encode(size_t index, V& v) const
24745                 {
24746                         if(index != type) {return false;} return v(ref_nested());
24747
24748                 }
24749                 private:
24750                 size_t type {0};
24751
24752         };
24753
24754 };
24755 /*
24756 E-RABs-ToBeReleased-List-RelReq ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-RelReqItemIEs} }
24757 */
24758
24759 struct E_RABs_ToBeReleased_List_RelReq_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>
24760 {
24761         static constexpr const char* name() {return "E_RABs_ToBeReleased_List_RelReq_elm";}
24762         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_RelReqItemIEs>;
24763
24764 };
24765 struct E_RABs_ToBeReleased_List_RelReq : asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>
24766 {
24767         static constexpr const char* name() {return "E-RABs-ToBeReleased-List-RelReq";}
24768         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_List_RelReq_elm>;
24769         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
24770
24771 };
24772 /*
24773 E-RABs-ToBeReleased-ModReqdItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24774         ...
24775 }
24776 */
24777
24778 struct E_RABs_ToBeReleased_ModReqdItemExtIEs
24779 {
24780         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24781         {
24782                 size_t get_index() const {return type;}
24783                 bool is_unknown() const { return type == 1; }
24784                 void clear() {type = 0;}
24785                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24786                 template<typename V>  bool decode(V& v)
24787                 {
24788                         clear();
24789                         if(!v(ref_nested())) return false;
24790                         { type = 1; return true;}
24791                         return false;
24792
24793                 }
24794                 template<typename V> bool encode(V& v) const
24795                 {
24796                         return v(ref_nested());
24797
24798                 }
24799                 protected:
24800                 template<typename V>  bool decode(size_t index, V& v)
24801                 {
24802                         clear();
24803                         switch(index)
24804                         {
24805                         case 1: type = 1; return v(ref_nested());
24806                         ref_nested().clear();
24807                         }
24808                         return false;
24809
24810                 }
24811                 template<typename V> bool encode(size_t index, V& v) const
24812                 {
24813                         if(index != type) {return false;} return v(ref_nested());
24814
24815                 }
24816                 private:
24817                 size_t type {0};
24818
24819         };
24820         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24821         {
24822                 size_t get_index() const {return type;}
24823                 bool is_unknown() const { return type == 1; }
24824                 void clear() {type = 0;}
24825                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24826                 template<typename V>  bool decode(V& v)
24827                 {
24828                         clear();
24829                         if(!v(ref_nested())) return false;
24830                         { type = 1; return true;}
24831                         return false;
24832
24833                 }
24834                 template<typename V> bool encode(V& v) const
24835                 {
24836                         return v(ref_nested());
24837
24838                 }
24839                 protected:
24840                 template<typename V>  bool decode(size_t index, V& v)
24841                 {
24842                         clear();
24843                         switch(index)
24844                         {
24845                         case 1: type = 1; return v(ref_nested());
24846                         ref_nested().clear();
24847                         }
24848                         return false;
24849
24850                 }
24851                 template<typename V> bool encode(size_t index, V& v) const
24852                 {
24853                         if(index != type) {return false;} return v(ref_nested());
24854
24855                 }
24856                 private:
24857                 size_t type {0};
24858
24859         };
24860         struct Extension_t : asn::typefield<true>
24861         {
24862                 ~Extension_t()  {clear();}
24863                 size_t get_index() const {return type;}
24864                 bool is_unknown() const { return type == 1; }
24865                 void clear()
24866                 {
24867                         type = 0; ref_nested().clear();
24868                 }
24869                 template<typename V> static inline void enumerate(V& v)
24870                 {
24871
24872                 }
24873                 protected:
24874                 template<typename V> bool decode(size_t index, V& v)
24875                 {
24876                         clear();
24877                         switch(index)
24878                         {
24879                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24880                         }
24881                         return false;
24882
24883                 }
24884                 template<typename V> bool encode(size_t index, V& v) const
24885                 {
24886                         if(index != type) return false;
24887                         return false;
24888
24889                 }
24890                 private:
24891                 size_t type {0};
24892
24893         };
24894         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24895         {
24896                 size_t get_index() const {return type;}
24897                 bool is_unknown() const { return type == 1; }
24898                 void clear() {type = 0;}
24899                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24900                 template<typename V>  bool decode(V& v)
24901                 {
24902                         clear();
24903                         if(!v(ref_nested())) return false;
24904                         { type = 1; return true;}
24905                         return false;
24906
24907                 }
24908                 template<typename V> bool encode(V& v) const
24909                 {
24910                         return v(ref_nested());
24911
24912                 }
24913                 protected:
24914                 template<typename V>  bool decode(size_t index, V& v)
24915                 {
24916                         clear();
24917                         switch(index)
24918                         {
24919                         case 1: type = 1; return v(ref_nested());
24920                         ref_nested().clear();
24921                         }
24922                         return false;
24923
24924                 }
24925                 template<typename V> bool encode(size_t index, V& v) const
24926                 {
24927                         if(index != type) {return false;} return v(ref_nested());
24928
24929                 }
24930                 private:
24931                 size_t type {0};
24932
24933         };
24934
24935 };
24936 /*
24937 E-RABs-ToBeReleased-ModReqdItem ::= SEQUENCE {
24938         e-RAB-ID                                                E-RAB-ID,
24939         cause                                                   Cause,
24940         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-ModReqdItemExtIEs} } OPTIONAL,
24941         ...
24942 }
24943 */
24944
24945 struct E_RABs_ToBeReleased_ModReqdItem : asn::sequence<3, 0, true, 1>
24946 {
24947         static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqdItem";}
24948         using parent_t = asn::sequence<3, 0, true, 1>;
24949         struct e_RAB_ID_t : E_RAB_ID
24950         {
24951                 static constexpr const char* name() {return "e_RAB_ID_t";}
24952                 using parent_t = E_RAB_ID;
24953
24954         };
24955         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
24956         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
24957         struct cause_t : Cause
24958         {
24959                 static constexpr const char* name() {return "cause_t";}
24960                 using parent_t = Cause;
24961
24962         };
24963         cause_t& ref_cause() {return cause;}
24964         cause_t const& ref_cause() const {return cause;}
24965         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqdItemExtIEs>
24966         {
24967                 static constexpr const char* name() {return "iE_Extensions_t";}
24968                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_ModReqdItemExtIEs>;
24969                 static constexpr bool optional = true;
24970
24971         };
24972         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24973         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24974         template<typename V> void decode(V& v)
24975         {
24976                 v(e_RAB_ID);
24977                 v(cause);
24978                 v(iE_Extensions);
24979
24980         };
24981         template<typename V> void encode(V& v) const
24982         {
24983                 v(e_RAB_ID);
24984                 v(cause);
24985                 v(iE_Extensions);
24986
24987         };
24988         void clear()
24989         {
24990                 e_RAB_ID.clear();
24991                 cause.clear();
24992                 iE_Extensions.clear();
24993
24994         };
24995         private:
24996         e_RAB_ID_t      e_RAB_ID;
24997         cause_t cause;
24998         iE_Extensions_t iE_Extensions;
24999
25000 };
25001 /*
25002 E-RABs-ToBeReleased-ModReqdItemIEs X2AP-PROTOCOL-IES ::= {
25003         { ID id-E-RABs-ToBeReleased-ModReqdItem  CRITICALITY ignore             TYPE E-RABs-ToBeReleased-ModReqdItem    PRESENCE mandatory },
25004         ...
25005 }
25006 */
25007
25008 struct E_RABs_ToBeReleased_ModReqdItemIEs
25009 {
25010         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
25011         {
25012                 size_t get_index() const {return type;}
25013                 bool is_unknown() const { return type == 2; }
25014                 void clear() {type = 0;}
25015                 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(id_E_RABs_ToBeReleased_ModReqdItem); type=1;}
25016                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
25017                 template<typename V>  bool decode(V& v)
25018                 {
25019                         clear();
25020                         if(!v(ref_nested())) return false;
25021                         if(equal(id_E_RABs_ToBeReleased_ModReqdItem)) { type = 1; return true; }
25022                         else { type = 2; return true;}
25023                         return false;
25024
25025                 }
25026                 template<typename V> bool encode(V& v) const
25027                 {
25028                         return v(ref_nested());
25029
25030                 }
25031                 protected:
25032                 template<typename V>  bool decode(size_t index, V& v)
25033                 {
25034                         clear();
25035                         switch(index)
25036                         {
25037                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqdItem);} return false;
25038                         case 2: type = 2; return v(ref_nested());
25039                         ref_nested().clear();
25040                         }
25041                         return false;
25042
25043                 }
25044                 template<typename V> bool encode(size_t index, V& v) const
25045                 {
25046                         if(index != type) {return false;} return v(ref_nested());
25047
25048                 }
25049                 private:
25050                 size_t type {0};
25051
25052         };
25053         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
25054         {
25055                 size_t get_index() const {return type;}
25056                 bool is_unknown() const { return type == 2; }
25057                 void clear() {type = 0;}
25058                 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(ignore); type=1;}
25059                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
25060                 template<typename V>  bool decode(V& v)
25061                 {
25062                         clear();
25063                         if(!v(ref_nested())) return false;
25064                         if(equal(ignore)) { type = 1; return true; }
25065                         else { type = 2; return true;}
25066                         return false;
25067
25068                 }
25069                 template<typename V> bool encode(V& v) const
25070                 {
25071                         return v(ref_nested());
25072
25073                 }
25074                 protected:
25075                 template<typename V>  bool decode(size_t index, V& v)
25076                 {
25077                         clear();
25078                         switch(index)
25079                         {
25080                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
25081                         case 2: type = 2; return v(ref_nested());
25082                         ref_nested().clear();
25083                         }
25084                         return false;
25085
25086                 }
25087                 template<typename V> bool encode(size_t index, V& v) const
25088                 {
25089                         if(index != type) {return false;} return v(ref_nested());
25090
25091                 }
25092                 private:
25093                 size_t type {0};
25094
25095         };
25096         struct Value_t : asn::typefield<true>
25097         {
25098                 ~Value_t()      {clear();}
25099                 size_t get_index() const {return type;}
25100                 E_RABs_ToBeReleased_ModReqdItem& select_id_E_RABs_ToBeReleased_ModReqdItem() { return set<E_RABs_ToBeReleased_ModReqdItem>(1); }
25101                 E_RABs_ToBeReleased_ModReqdItem const* get_id_E_RABs_ToBeReleased_ModReqdItem() const { return get<E_RABs_ToBeReleased_ModReqdItem>(1); }
25102                 bool is_unknown() const { return type == 2; }
25103                 void clear()
25104                 {
25105                         switch(type)
25106                         {
25107                         case 1: var.destroy<E_RABs_ToBeReleased_ModReqdItem>(); break;
25108                         }
25109                         type = 0; ref_nested().clear();
25110                 }
25111                 template<typename V> static inline void enumerate(V& v)
25112                 {
25113                         v.template operator()<E_RABs_ToBeReleased_ModReqdItem>(1);
25114
25115                 }
25116                 protected:
25117                 template<typename V> bool decode(size_t index, V& v)
25118                 {
25119                         clear();
25120                         switch(index)
25121                         {
25122                         case 1: v(select_id_E_RABs_ToBeReleased_ModReqdItem()); return true;
25123                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
25124                         }
25125                         return false;
25126
25127                 }
25128                 template<typename V> bool encode(size_t index, V& v) const
25129                 {
25130                         if(index != type) return false;
25131                         switch(type)
25132                         {
25133                         case 1: v(var.as<E_RABs_ToBeReleased_ModReqdItem>()); return true;
25134                         }
25135                         return false;
25136
25137                 }
25138                 private:
25139                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
25140                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
25141                 union union_type
25142                 {
25143                         char dummy1[sizeof(E_RABs_ToBeReleased_ModReqdItem)];
25144
25145                 };
25146                 asn::variant<sizeof(union_type)> var;
25147                 size_t type {0};
25148
25149         };
25150         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
25151         {
25152                 size_t get_index() const {return type;}
25153                 bool is_unknown() const { return type == 2; }
25154                 void clear() {type = 0;}
25155                 void select_id_E_RABs_ToBeReleased_ModReqdItem() { set(mandatory); type=1;}
25156                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
25157                 template<typename V>  bool decode(V& v)
25158                 {
25159                         clear();
25160                         if(!v(ref_nested())) return false;
25161                         if(equal(mandatory)) { type = 1; return true; }
25162                         else { type = 2; return true;}
25163                         return false;
25164
25165                 }
25166                 template<typename V> bool encode(V& v) const
25167                 {
25168                         return v(ref_nested());
25169
25170                 }
25171                 protected:
25172                 template<typename V>  bool decode(size_t index, V& v)
25173                 {
25174                         clear();
25175                         switch(index)
25176                         {
25177                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
25178                         case 2: type = 2; return v(ref_nested());
25179                         ref_nested().clear();
25180                         }
25181                         return false;
25182
25183                 }
25184                 template<typename V> bool encode(size_t index, V& v) const
25185                 {
25186                         if(index != type) {return false;} return v(ref_nested());
25187
25188                 }
25189                 private:
25190                 size_t type {0};
25191
25192         };
25193
25194 };
25195 /*
25196 E-RABs-ToBeReleased-ModReqd ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-ModReqdItemIEs} }
25197 */
25198
25199 struct E_RABs_ToBeReleased_ModReqd_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>
25200 {
25201         static constexpr const char* name() {return "E_RABs_ToBeReleased_ModReqd_elm";}
25202         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_ModReqdItemIEs>;
25203
25204 };
25205 struct E_RABs_ToBeReleased_ModReqd : asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>
25206 {
25207         static constexpr const char* name() {return "E-RABs-ToBeReleased-ModReqd";}
25208         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_ModReqd_elm>;
25209         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
25210
25211 };
25212 /*
25213 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25214         ...
25215 }
25216 */
25217
25218 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs
25219 {
25220         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25221         {
25222                 size_t get_index() const {return type;}
25223                 bool is_unknown() const { return type == 1; }
25224                 void clear() {type = 0;}
25225                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25226                 template<typename V>  bool decode(V& v)
25227                 {
25228                         clear();
25229                         if(!v(ref_nested())) return false;
25230                         { type = 1; return true;}
25231                         return false;
25232
25233                 }
25234                 template<typename V> bool encode(V& v) const
25235                 {
25236                         return v(ref_nested());
25237
25238                 }
25239                 protected:
25240                 template<typename V>  bool decode(size_t index, V& v)
25241                 {
25242                         clear();
25243                         switch(index)
25244                         {
25245                         case 1: type = 1; return v(ref_nested());
25246                         ref_nested().clear();
25247                         }
25248                         return false;
25249
25250                 }
25251                 template<typename V> bool encode(size_t index, V& v) const
25252                 {
25253                         if(index != type) {return false;} return v(ref_nested());
25254
25255                 }
25256                 private:
25257                 size_t type {0};
25258
25259         };
25260         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25261         {
25262                 size_t get_index() const {return type;}
25263                 bool is_unknown() const { return type == 1; }
25264                 void clear() {type = 0;}
25265                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25266                 template<typename V>  bool decode(V& v)
25267                 {
25268                         clear();
25269                         if(!v(ref_nested())) return false;
25270                         { type = 1; return true;}
25271                         return false;
25272
25273                 }
25274                 template<typename V> bool encode(V& v) const
25275                 {
25276                         return v(ref_nested());
25277
25278                 }
25279                 protected:
25280                 template<typename V>  bool decode(size_t index, V& v)
25281                 {
25282                         clear();
25283                         switch(index)
25284                         {
25285                         case 1: type = 1; return v(ref_nested());
25286                         ref_nested().clear();
25287                         }
25288                         return false;
25289
25290                 }
25291                 template<typename V> bool encode(size_t index, V& v) const
25292                 {
25293                         if(index != type) {return false;} return v(ref_nested());
25294
25295                 }
25296                 private:
25297                 size_t type {0};
25298
25299         };
25300         struct Extension_t : asn::typefield<true>
25301         {
25302                 ~Extension_t()  {clear();}
25303                 size_t get_index() const {return type;}
25304                 bool is_unknown() const { return type == 1; }
25305                 void clear()
25306                 {
25307                         type = 0; ref_nested().clear();
25308                 }
25309                 template<typename V> static inline void enumerate(V& v)
25310                 {
25311
25312                 }
25313                 protected:
25314                 template<typename V> bool decode(size_t index, V& v)
25315                 {
25316                         clear();
25317                         switch(index)
25318                         {
25319                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25320                         }
25321                         return false;
25322
25323                 }
25324                 template<typename V> bool encode(size_t index, V& v) const
25325                 {
25326                         if(index != type) return false;
25327                         return false;
25328
25329                 }
25330                 private:
25331                 size_t type {0};
25332
25333         };
25334         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25335         {
25336                 size_t get_index() const {return type;}
25337                 bool is_unknown() const { return type == 1; }
25338                 void clear() {type = 0;}
25339                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25340                 template<typename V>  bool decode(V& v)
25341                 {
25342                         clear();
25343                         if(!v(ref_nested())) return false;
25344                         { type = 1; return true;}
25345                         return false;
25346
25347                 }
25348                 template<typename V> bool encode(V& v) const
25349                 {
25350                         return v(ref_nested());
25351
25352                 }
25353                 protected:
25354                 template<typename V>  bool decode(size_t index, V& v)
25355                 {
25356                         clear();
25357                         switch(index)
25358                         {
25359                         case 1: type = 1; return v(ref_nested());
25360                         ref_nested().clear();
25361                         }
25362                         return false;
25363
25364                 }
25365                 template<typename V> bool encode(size_t index, V& v) const
25366                 {
25367                         if(index != type) {return false;} return v(ref_nested());
25368
25369                 }
25370                 private:
25371                 size_t type {0};
25372
25373         };
25374
25375 };
25376 /*
25377 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent ::= SEQUENCE {
25378         uL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
25379         dL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
25380         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
25381         ...
25382 }
25383 */
25384
25385 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
25386 {
25387         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent";}
25388         using parent_t = asn::sequence<3, 0, true, 3>;
25389         struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
25390         {
25391                 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
25392                 using parent_t = GTPtunnelEndpoint;
25393                 static constexpr bool optional = true;
25394
25395         };
25396         uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
25397         uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
25398         struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
25399         {
25400                 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
25401                 using parent_t = GTPtunnelEndpoint;
25402                 static constexpr bool optional = true;
25403
25404         };
25405         dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
25406         dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
25407         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>
25408         {
25409                 static constexpr const char* name() {return "iE_Extensions_t";}
25410                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresentExtIEs>;
25411                 static constexpr bool optional = true;
25412
25413         };
25414         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25415         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25416         template<typename V> void decode(V& v)
25417         {
25418                 v(uL_GTPtunnelEndpoint);
25419                 v(dL_GTPtunnelEndpoint);
25420                 v(iE_Extensions);
25421
25422         };
25423         template<typename V> void encode(V& v) const
25424         {
25425                 v(uL_GTPtunnelEndpoint);
25426                 v(dL_GTPtunnelEndpoint);
25427                 v(iE_Extensions);
25428
25429         };
25430         void clear()
25431         {
25432                 uL_GTPtunnelEndpoint.clear();
25433                 dL_GTPtunnelEndpoint.clear();
25434                 iE_Extensions.clear();
25435
25436         };
25437         private:
25438         uL_GTPtunnelEndpoint_t  uL_GTPtunnelEndpoint;
25439         dL_GTPtunnelEndpoint_t  dL_GTPtunnelEndpoint;
25440         iE_Extensions_t iE_Extensions;
25441
25442 };
25443 /*
25444 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25445         ...
25446 }
25447 */
25448
25449 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs
25450 {
25451         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25452         {
25453                 size_t get_index() const {return type;}
25454                 bool is_unknown() const { return type == 1; }
25455                 void clear() {type = 0;}
25456                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25457                 template<typename V>  bool decode(V& v)
25458                 {
25459                         clear();
25460                         if(!v(ref_nested())) return false;
25461                         { type = 1; return true;}
25462                         return false;
25463
25464                 }
25465                 template<typename V> bool encode(V& v) const
25466                 {
25467                         return v(ref_nested());
25468
25469                 }
25470                 protected:
25471                 template<typename V>  bool decode(size_t index, V& v)
25472                 {
25473                         clear();
25474                         switch(index)
25475                         {
25476                         case 1: type = 1; return v(ref_nested());
25477                         ref_nested().clear();
25478                         }
25479                         return false;
25480
25481                 }
25482                 template<typename V> bool encode(size_t index, V& v) const
25483                 {
25484                         if(index != type) {return false;} return v(ref_nested());
25485
25486                 }
25487                 private:
25488                 size_t type {0};
25489
25490         };
25491         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25492         {
25493                 size_t get_index() const {return type;}
25494                 bool is_unknown() const { return type == 1; }
25495                 void clear() {type = 0;}
25496                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25497                 template<typename V>  bool decode(V& v)
25498                 {
25499                         clear();
25500                         if(!v(ref_nested())) return false;
25501                         { type = 1; return true;}
25502                         return false;
25503
25504                 }
25505                 template<typename V> bool encode(V& v) const
25506                 {
25507                         return v(ref_nested());
25508
25509                 }
25510                 protected:
25511                 template<typename V>  bool decode(size_t index, V& v)
25512                 {
25513                         clear();
25514                         switch(index)
25515                         {
25516                         case 1: type = 1; return v(ref_nested());
25517                         ref_nested().clear();
25518                         }
25519                         return false;
25520
25521                 }
25522                 template<typename V> bool encode(size_t index, V& v) const
25523                 {
25524                         if(index != type) {return false;} return v(ref_nested());
25525
25526                 }
25527                 private:
25528                 size_t type {0};
25529
25530         };
25531         struct Extension_t : asn::typefield<true>
25532         {
25533                 ~Extension_t()  {clear();}
25534                 size_t get_index() const {return type;}
25535                 bool is_unknown() const { return type == 1; }
25536                 void clear()
25537                 {
25538                         type = 0; ref_nested().clear();
25539                 }
25540                 template<typename V> static inline void enumerate(V& v)
25541                 {
25542
25543                 }
25544                 protected:
25545                 template<typename V> bool decode(size_t index, V& v)
25546                 {
25547                         clear();
25548                         switch(index)
25549                         {
25550                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25551                         }
25552                         return false;
25553
25554                 }
25555                 template<typename V> bool encode(size_t index, V& v) const
25556                 {
25557                         if(index != type) return false;
25558                         return false;
25559
25560                 }
25561                 private:
25562                 size_t type {0};
25563
25564         };
25565         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25566         {
25567                 size_t get_index() const {return type;}
25568                 bool is_unknown() const { return type == 1; }
25569                 void clear() {type = 0;}
25570                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25571                 template<typename V>  bool decode(V& v)
25572                 {
25573                         clear();
25574                         if(!v(ref_nested())) return false;
25575                         { type = 1; return true;}
25576                         return false;
25577
25578                 }
25579                 template<typename V> bool encode(V& v) const
25580                 {
25581                         return v(ref_nested());
25582
25583                 }
25584                 protected:
25585                 template<typename V>  bool decode(size_t index, V& v)
25586                 {
25587                         clear();
25588                         switch(index)
25589                         {
25590                         case 1: type = 1; return v(ref_nested());
25591                         ref_nested().clear();
25592                         }
25593                         return false;
25594
25595                 }
25596                 template<typename V> bool encode(size_t index, V& v) const
25597                 {
25598                         if(index != type) {return false;} return v(ref_nested());
25599
25600                 }
25601                 private:
25602                 size_t type {0};
25603
25604         };
25605
25606 };
25607 /*
25608 E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
25609         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresentExtIEs} }  OPTIONAL,
25610         ...
25611 }
25612 */
25613
25614 struct E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
25615 {
25616         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent";}
25617         using parent_t = asn::sequence<1, 0, true, 1>;
25618         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>
25619         {
25620                 static constexpr const char* name() {return "iE_Extensions_t";}
25621                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresentExtIEs>;
25622                 static constexpr bool optional = true;
25623
25624         };
25625         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25626         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25627         template<typename V> void decode(V& v)
25628         {
25629                 v(iE_Extensions);
25630
25631         };
25632         template<typename V> void encode(V& v) const
25633         {
25634                 v(iE_Extensions);
25635
25636         };
25637         void clear()
25638         {
25639                 iE_Extensions.clear();
25640
25641         };
25642         private:
25643         iE_Extensions_t iE_Extensions;
25644
25645 };
25646 /*
25647 E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25648         ...
25649 }
25650 */
25651
25652 struct E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs
25653 {
25654         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25655         {
25656                 size_t get_index() const {return type;}
25657                 bool is_unknown() const { return type == 1; }
25658                 void clear() {type = 0;}
25659                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25660                 template<typename V>  bool decode(V& v)
25661                 {
25662                         clear();
25663                         if(!v(ref_nested())) return false;
25664                         { type = 1; return true;}
25665                         return false;
25666
25667                 }
25668                 template<typename V> bool encode(V& v) const
25669                 {
25670                         return v(ref_nested());
25671
25672                 }
25673                 protected:
25674                 template<typename V>  bool decode(size_t index, V& v)
25675                 {
25676                         clear();
25677                         switch(index)
25678                         {
25679                         case 1: type = 1; return v(ref_nested());
25680                         ref_nested().clear();
25681                         }
25682                         return false;
25683
25684                 }
25685                 template<typename V> bool encode(size_t index, V& v) const
25686                 {
25687                         if(index != type) {return false;} return v(ref_nested());
25688
25689                 }
25690                 private:
25691                 size_t type {0};
25692
25693         };
25694         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25695         {
25696                 size_t get_index() const {return type;}
25697                 bool is_unknown() const { return type == 1; }
25698                 void clear() {type = 0;}
25699                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25700                 template<typename V>  bool decode(V& v)
25701                 {
25702                         clear();
25703                         if(!v(ref_nested())) return false;
25704                         { type = 1; return true;}
25705                         return false;
25706
25707                 }
25708                 template<typename V> bool encode(V& v) const
25709                 {
25710                         return v(ref_nested());
25711
25712                 }
25713                 protected:
25714                 template<typename V>  bool decode(size_t index, V& v)
25715                 {
25716                         clear();
25717                         switch(index)
25718                         {
25719                         case 1: type = 1; return v(ref_nested());
25720                         ref_nested().clear();
25721                         }
25722                         return false;
25723
25724                 }
25725                 template<typename V> bool encode(size_t index, V& v) const
25726                 {
25727                         if(index != type) {return false;} return v(ref_nested());
25728
25729                 }
25730                 private:
25731                 size_t type {0};
25732
25733         };
25734         struct Extension_t : asn::typefield<true>
25735         {
25736                 ~Extension_t()  {clear();}
25737                 size_t get_index() const {return type;}
25738                 bool is_unknown() const { return type == 1; }
25739                 void clear()
25740                 {
25741                         type = 0; ref_nested().clear();
25742                 }
25743                 template<typename V> static inline void enumerate(V& v)
25744                 {
25745
25746                 }
25747                 protected:
25748                 template<typename V> bool decode(size_t index, V& v)
25749                 {
25750                         clear();
25751                         switch(index)
25752                         {
25753                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25754                         }
25755                         return false;
25756
25757                 }
25758                 template<typename V> bool encode(size_t index, V& v) const
25759                 {
25760                         if(index != type) return false;
25761                         return false;
25762
25763                 }
25764                 private:
25765                 size_t type {0};
25766
25767         };
25768         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25769         {
25770                 size_t get_index() const {return type;}
25771                 bool is_unknown() const { return type == 1; }
25772                 void clear() {type = 0;}
25773                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25774                 template<typename V>  bool decode(V& v)
25775                 {
25776                         clear();
25777                         if(!v(ref_nested())) return false;
25778                         { type = 1; return true;}
25779                         return false;
25780
25781                 }
25782                 template<typename V> bool encode(V& v) const
25783                 {
25784                         return v(ref_nested());
25785
25786                 }
25787                 protected:
25788                 template<typename V>  bool decode(size_t index, V& v)
25789                 {
25790                         clear();
25791                         switch(index)
25792                         {
25793                         case 1: type = 1; return v(ref_nested());
25794                         ref_nested().clear();
25795                         }
25796                         return false;
25797
25798                 }
25799                 template<typename V> bool encode(size_t index, V& v) const
25800                 {
25801                         if(index != type) {return false;} return v(ref_nested());
25802
25803                 }
25804                 private:
25805                 size_t type {0};
25806
25807         };
25808
25809 };
25810 /*
25811 E-RABs-ToBeReleased-SgNBChaConf-Item ::= SEQUENCE {
25812         e-RAB-ID                                                        E-RAB-ID,
25813         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
25814         resource-configuration                          CHOICE {
25815                 sgNBPDCPpresent                                         E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPpresent,
25816                 sgNBPDCPnotpresent                                      E-RABs-ToBeReleased-SgNBChaConf-Item-SgNBPDCPnotpresent,
25817                 ...
25818         },
25819         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBChaConf-ItemExtIEs} }     OPTIONAL,
25820         ...
25821 }
25822 */
25823
25824 struct E_RABs_ToBeReleased_SgNBChaConf_Item : asn::sequence<4, 0, true, 1>
25825 {
25826         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConf-Item";}
25827         using parent_t = asn::sequence<4, 0, true, 1>;
25828         struct e_RAB_ID_t : E_RAB_ID
25829         {
25830                 static constexpr const char* name() {return "e_RAB_ID_t";}
25831                 using parent_t = E_RAB_ID;
25832
25833         };
25834         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
25835         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
25836         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
25837         {
25838                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
25839                 using parent_t = EN_DC_ResourceConfiguration;
25840
25841         };
25842         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
25843         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
25844         struct resource_configuration_t : asn::choice<2, 0, true>
25845         {
25846                 static constexpr const char* name() {return "resource_configuration_t";}
25847                 using parent_t = asn::choice<2, 0, true>;
25848                 index_type get_index() const {return index;}
25849                 bool is_unknown() const {return index == 3;}
25850                 void set_unknown() { set_index(3);  }
25851                 ~resource_configuration_t() {clear();}
25852                 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent
25853                 {
25854                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
25855                         using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPpresent;
25856
25857                 };
25858                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent
25859                 {
25860                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
25861                         using parent_t = E_RABs_ToBeReleased_SgNBChaConf_Item_SgNBPDCPnotpresent;
25862
25863                 };
25864                 void clear()
25865                 {
25866                         switch(get_index())
25867                         {
25868                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
25869                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
25870                         }
25871                         index = 0;
25872                         base::clear();
25873                 }
25874                 template<typename V> bool decode(size_t idx, V& v)
25875                 {
25876                         clear();
25877                         switch(idx)
25878                         {
25879                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
25880                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
25881                         }
25882                         return false;
25883
25884                 }
25885                 template<typename V> bool encode(V& v) const
25886                 {
25887                         switch(get_index())
25888                         {
25889                         case 1: return v(var.as<sgNBPDCPpresent_t>());
25890                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
25891                         }
25892                         return false;
25893                 }
25894                 template<typename V> static inline void enumerate(V& v)
25895                 {
25896                         v.template operator()<sgNBPDCPpresent_t>(1);
25897                         v.template operator()<sgNBPDCPnotpresent_t>(2);
25898
25899                 }
25900                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
25901                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
25902                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
25903                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
25904                 private:
25905                 void set_index(index_type i) {index = i; base::set();}
25906                 union union_type
25907                 {
25908                         char dummy1[sizeof(sgNBPDCPpresent_t)];
25909                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
25910
25911                 };
25912                 asn::variant<sizeof(union_type)>        var;
25913                 index_type      index {0};
25914         };
25915         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
25916         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
25917         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>
25918         {
25919                 static constexpr const char* name() {return "iE_Extensions_t";}
25920                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBChaConf_ItemExtIEs>;
25921                 static constexpr bool optional = true;
25922
25923         };
25924         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25925         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25926         template<typename V> void decode(V& v)
25927         {
25928                 v(e_RAB_ID);
25929                 v(en_DC_ResourceConfiguration);
25930                 v(resource_configuration);
25931                 v(iE_Extensions);
25932
25933         };
25934         template<typename V> void encode(V& v) const
25935         {
25936                 v(e_RAB_ID);
25937                 v(en_DC_ResourceConfiguration);
25938                 v(resource_configuration);
25939                 v(iE_Extensions);
25940
25941         };
25942         void clear()
25943         {
25944                 e_RAB_ID.clear();
25945                 en_DC_ResourceConfiguration.clear();
25946                 resource_configuration.clear();
25947                 iE_Extensions.clear();
25948
25949         };
25950         private:
25951         e_RAB_ID_t      e_RAB_ID;
25952         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
25953         resource_configuration_t        resource_configuration;
25954         iE_Extensions_t iE_Extensions;
25955
25956 };
25957 /*
25958 E-RABs-ToBeReleased-SgNBChaConf-ItemIEs X2AP-PROTOCOL-IES ::= {
25959         { ID id-E-RABs-ToBeReleased-SgNBChaConf-Item            CRITICALITY ignore              TYPE E-RABs-ToBeReleased-SgNBChaConf-Item               PRESENCE mandatory},
25960         ...
25961 }
25962 */
25963
25964 struct E_RABs_ToBeReleased_SgNBChaConf_ItemIEs
25965 {
25966         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
25967         {
25968                 size_t get_index() const {return type;}
25969                 bool is_unknown() const { return type == 2; }
25970                 void clear() {type = 0;}
25971                 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(id_E_RABs_ToBeReleased_SgNBChaConf_Item); type=1;}
25972                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
25973                 template<typename V>  bool decode(V& v)
25974                 {
25975                         clear();
25976                         if(!v(ref_nested())) return false;
25977                         if(equal(id_E_RABs_ToBeReleased_SgNBChaConf_Item)) { type = 1; return true; }
25978                         else { type = 2; return true;}
25979                         return false;
25980
25981                 }
25982                 template<typename V> bool encode(V& v) const
25983                 {
25984                         return v(ref_nested());
25985
25986                 }
25987                 protected:
25988                 template<typename V>  bool decode(size_t index, V& v)
25989                 {
25990                         clear();
25991                         switch(index)
25992                         {
25993                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBChaConf_Item);} return false;
25994                         case 2: type = 2; return v(ref_nested());
25995                         ref_nested().clear();
25996                         }
25997                         return false;
25998
25999                 }
26000                 template<typename V> bool encode(size_t index, V& v) const
26001                 {
26002                         if(index != type) {return false;} return v(ref_nested());
26003
26004                 }
26005                 private:
26006                 size_t type {0};
26007
26008         };
26009         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
26010         {
26011                 size_t get_index() const {return type;}
26012                 bool is_unknown() const { return type == 2; }
26013                 void clear() {type = 0;}
26014                 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(ignore); type=1;}
26015                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
26016                 template<typename V>  bool decode(V& v)
26017                 {
26018                         clear();
26019                         if(!v(ref_nested())) return false;
26020                         if(equal(ignore)) { type = 1; return true; }
26021                         else { type = 2; return true;}
26022                         return false;
26023
26024                 }
26025                 template<typename V> bool encode(V& v) const
26026                 {
26027                         return v(ref_nested());
26028
26029                 }
26030                 protected:
26031                 template<typename V>  bool decode(size_t index, V& v)
26032                 {
26033                         clear();
26034                         switch(index)
26035                         {
26036                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26037                         case 2: type = 2; return v(ref_nested());
26038                         ref_nested().clear();
26039                         }
26040                         return false;
26041
26042                 }
26043                 template<typename V> bool encode(size_t index, V& v) const
26044                 {
26045                         if(index != type) {return false;} return v(ref_nested());
26046
26047                 }
26048                 private:
26049                 size_t type {0};
26050
26051         };
26052         struct Value_t : asn::typefield<true>
26053         {
26054                 ~Value_t()      {clear();}
26055                 size_t get_index() const {return type;}
26056                 E_RABs_ToBeReleased_SgNBChaConf_Item& select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { return set<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
26057                 E_RABs_ToBeReleased_SgNBChaConf_Item const* get_id_E_RABs_ToBeReleased_SgNBChaConf_Item() const { return get<E_RABs_ToBeReleased_SgNBChaConf_Item>(1); }
26058                 bool is_unknown() const { return type == 2; }
26059                 void clear()
26060                 {
26061                         switch(type)
26062                         {
26063                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBChaConf_Item>(); break;
26064                         }
26065                         type = 0; ref_nested().clear();
26066                 }
26067                 template<typename V> static inline void enumerate(V& v)
26068                 {
26069                         v.template operator()<E_RABs_ToBeReleased_SgNBChaConf_Item>(1);
26070
26071                 }
26072                 protected:
26073                 template<typename V> bool decode(size_t index, V& v)
26074                 {
26075                         clear();
26076                         switch(index)
26077                         {
26078                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBChaConf_Item()); return true;
26079                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
26080                         }
26081                         return false;
26082
26083                 }
26084                 template<typename V> bool encode(size_t index, V& v) const
26085                 {
26086                         if(index != type) return false;
26087                         switch(type)
26088                         {
26089                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBChaConf_Item>()); return true;
26090                         }
26091                         return false;
26092
26093                 }
26094                 private:
26095                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
26096                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
26097                 union union_type
26098                 {
26099                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBChaConf_Item)];
26100
26101                 };
26102                 asn::variant<sizeof(union_type)> var;
26103                 size_t type {0};
26104
26105         };
26106         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
26107         {
26108                 size_t get_index() const {return type;}
26109                 bool is_unknown() const { return type == 2; }
26110                 void clear() {type = 0;}
26111                 void select_id_E_RABs_ToBeReleased_SgNBChaConf_Item() { set(mandatory); type=1;}
26112                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
26113                 template<typename V>  bool decode(V& v)
26114                 {
26115                         clear();
26116                         if(!v(ref_nested())) return false;
26117                         if(equal(mandatory)) { type = 1; return true; }
26118                         else { type = 2; return true;}
26119                         return false;
26120
26121                 }
26122                 template<typename V> bool encode(V& v) const
26123                 {
26124                         return v(ref_nested());
26125
26126                 }
26127                 protected:
26128                 template<typename V>  bool decode(size_t index, V& v)
26129                 {
26130                         clear();
26131                         switch(index)
26132                         {
26133                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
26134                         case 2: type = 2; return v(ref_nested());
26135                         ref_nested().clear();
26136                         }
26137                         return false;
26138
26139                 }
26140                 template<typename V> bool encode(size_t index, V& v) const
26141                 {
26142                         if(index != type) {return false;} return v(ref_nested());
26143
26144                 }
26145                 private:
26146                 size_t type {0};
26147
26148         };
26149
26150 };
26151 /*
26152 E-RABs-ToBeReleased-SgNBChaConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBChaConf-ItemIEs} }
26153 */
26154
26155 struct E_RABs_ToBeReleased_SgNBChaConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>
26156 {
26157         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBChaConfList_elm";}
26158         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBChaConf_ItemIEs>;
26159
26160 };
26161 struct E_RABs_ToBeReleased_SgNBChaConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>
26162 {
26163         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBChaConfList";}
26164         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBChaConfList_elm>;
26165         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
26166
26167 };
26168 /*
26169 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26170         ...
26171 }
26172 */
26173
26174 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs
26175 {
26176         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26177         {
26178                 size_t get_index() const {return type;}
26179                 bool is_unknown() const { return type == 1; }
26180                 void clear() {type = 0;}
26181                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26182                 template<typename V>  bool decode(V& v)
26183                 {
26184                         clear();
26185                         if(!v(ref_nested())) return false;
26186                         { type = 1; return true;}
26187                         return false;
26188
26189                 }
26190                 template<typename V> bool encode(V& v) const
26191                 {
26192                         return v(ref_nested());
26193
26194                 }
26195                 protected:
26196                 template<typename V>  bool decode(size_t index, V& v)
26197                 {
26198                         clear();
26199                         switch(index)
26200                         {
26201                         case 1: type = 1; return v(ref_nested());
26202                         ref_nested().clear();
26203                         }
26204                         return false;
26205
26206                 }
26207                 template<typename V> bool encode(size_t index, V& v) const
26208                 {
26209                         if(index != type) {return false;} return v(ref_nested());
26210
26211                 }
26212                 private:
26213                 size_t type {0};
26214
26215         };
26216         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26217         {
26218                 size_t get_index() const {return type;}
26219                 bool is_unknown() const { return type == 1; }
26220                 void clear() {type = 0;}
26221                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26222                 template<typename V>  bool decode(V& v)
26223                 {
26224                         clear();
26225                         if(!v(ref_nested())) return false;
26226                         { type = 1; return true;}
26227                         return false;
26228
26229                 }
26230                 template<typename V> bool encode(V& v) const
26231                 {
26232                         return v(ref_nested());
26233
26234                 }
26235                 protected:
26236                 template<typename V>  bool decode(size_t index, V& v)
26237                 {
26238                         clear();
26239                         switch(index)
26240                         {
26241                         case 1: type = 1; return v(ref_nested());
26242                         ref_nested().clear();
26243                         }
26244                         return false;
26245
26246                 }
26247                 template<typename V> bool encode(size_t index, V& v) const
26248                 {
26249                         if(index != type) {return false;} return v(ref_nested());
26250
26251                 }
26252                 private:
26253                 size_t type {0};
26254
26255         };
26256         struct Extension_t : asn::typefield<true>
26257         {
26258                 ~Extension_t()  {clear();}
26259                 size_t get_index() const {return type;}
26260                 bool is_unknown() const { return type == 1; }
26261                 void clear()
26262                 {
26263                         type = 0; ref_nested().clear();
26264                 }
26265                 template<typename V> static inline void enumerate(V& v)
26266                 {
26267
26268                 }
26269                 protected:
26270                 template<typename V> bool decode(size_t index, V& v)
26271                 {
26272                         clear();
26273                         switch(index)
26274                         {
26275                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26276                         }
26277                         return false;
26278
26279                 }
26280                 template<typename V> bool encode(size_t index, V& v) const
26281                 {
26282                         if(index != type) return false;
26283                         return false;
26284
26285                 }
26286                 private:
26287                 size_t type {0};
26288
26289         };
26290         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26291         {
26292                 size_t get_index() const {return type;}
26293                 bool is_unknown() const { return type == 1; }
26294                 void clear() {type = 0;}
26295                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26296                 template<typename V>  bool decode(V& v)
26297                 {
26298                         clear();
26299                         if(!v(ref_nested())) return false;
26300                         { type = 1; return true;}
26301                         return false;
26302
26303                 }
26304                 template<typename V> bool encode(V& v) const
26305                 {
26306                         return v(ref_nested());
26307
26308                 }
26309                 protected:
26310                 template<typename V>  bool decode(size_t index, V& v)
26311                 {
26312                         clear();
26313                         switch(index)
26314                         {
26315                         case 1: type = 1; return v(ref_nested());
26316                         ref_nested().clear();
26317                         }
26318                         return false;
26319
26320                 }
26321                 template<typename V> bool encode(size_t index, V& v) const
26322                 {
26323                         if(index != type) {return false;} return v(ref_nested());
26324
26325                 }
26326                 private:
26327                 size_t type {0};
26328
26329         };
26330
26331 };
26332 /*
26333 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent ::= SEQUENCE {
26334         dL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
26335         uL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
26336         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresentExtIEs} }      OPTIONAL,
26337         ...
26338 }
26339 */
26340
26341 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
26342 {
26343         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent";}
26344         using parent_t = asn::sequence<3, 0, true, 3>;
26345         struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
26346         {
26347                 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
26348                 using parent_t = GTPtunnelEndpoint;
26349                 static constexpr bool optional = true;
26350
26351         };
26352         dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
26353         dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
26354         struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
26355         {
26356                 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
26357                 using parent_t = GTPtunnelEndpoint;
26358                 static constexpr bool optional = true;
26359
26360         };
26361         uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
26362         uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
26363         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>
26364         {
26365                 static constexpr const char* name() {return "iE_Extensions_t";}
26366                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresentExtIEs>;
26367                 static constexpr bool optional = true;
26368
26369         };
26370         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26371         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26372         template<typename V> void decode(V& v)
26373         {
26374                 v(dL_GTPtunnelEndpoint);
26375                 v(uL_GTPtunnelEndpoint);
26376                 v(iE_Extensions);
26377
26378         };
26379         template<typename V> void encode(V& v) const
26380         {
26381                 v(dL_GTPtunnelEndpoint);
26382                 v(uL_GTPtunnelEndpoint);
26383                 v(iE_Extensions);
26384
26385         };
26386         void clear()
26387         {
26388                 dL_GTPtunnelEndpoint.clear();
26389                 uL_GTPtunnelEndpoint.clear();
26390                 iE_Extensions.clear();
26391
26392         };
26393         private:
26394         dL_GTPtunnelEndpoint_t  dL_GTPtunnelEndpoint;
26395         uL_GTPtunnelEndpoint_t  uL_GTPtunnelEndpoint;
26396         iE_Extensions_t iE_Extensions;
26397
26398 };
26399 /*
26400 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26401         ...
26402 }
26403 */
26404
26405 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs
26406 {
26407         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26408         {
26409                 size_t get_index() const {return type;}
26410                 bool is_unknown() const { return type == 1; }
26411                 void clear() {type = 0;}
26412                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26413                 template<typename V>  bool decode(V& v)
26414                 {
26415                         clear();
26416                         if(!v(ref_nested())) return false;
26417                         { type = 1; return true;}
26418                         return false;
26419
26420                 }
26421                 template<typename V> bool encode(V& v) const
26422                 {
26423                         return v(ref_nested());
26424
26425                 }
26426                 protected:
26427                 template<typename V>  bool decode(size_t index, V& v)
26428                 {
26429                         clear();
26430                         switch(index)
26431                         {
26432                         case 1: type = 1; return v(ref_nested());
26433                         ref_nested().clear();
26434                         }
26435                         return false;
26436
26437                 }
26438                 template<typename V> bool encode(size_t index, V& v) const
26439                 {
26440                         if(index != type) {return false;} return v(ref_nested());
26441
26442                 }
26443                 private:
26444                 size_t type {0};
26445
26446         };
26447         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26448         {
26449                 size_t get_index() const {return type;}
26450                 bool is_unknown() const { return type == 1; }
26451                 void clear() {type = 0;}
26452                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26453                 template<typename V>  bool decode(V& v)
26454                 {
26455                         clear();
26456                         if(!v(ref_nested())) return false;
26457                         { type = 1; return true;}
26458                         return false;
26459
26460                 }
26461                 template<typename V> bool encode(V& v) const
26462                 {
26463                         return v(ref_nested());
26464
26465                 }
26466                 protected:
26467                 template<typename V>  bool decode(size_t index, V& v)
26468                 {
26469                         clear();
26470                         switch(index)
26471                         {
26472                         case 1: type = 1; return v(ref_nested());
26473                         ref_nested().clear();
26474                         }
26475                         return false;
26476
26477                 }
26478                 template<typename V> bool encode(size_t index, V& v) const
26479                 {
26480                         if(index != type) {return false;} return v(ref_nested());
26481
26482                 }
26483                 private:
26484                 size_t type {0};
26485
26486         };
26487         struct Extension_t : asn::typefield<true>
26488         {
26489                 ~Extension_t()  {clear();}
26490                 size_t get_index() const {return type;}
26491                 bool is_unknown() const { return type == 1; }
26492                 void clear()
26493                 {
26494                         type = 0; ref_nested().clear();
26495                 }
26496                 template<typename V> static inline void enumerate(V& v)
26497                 {
26498
26499                 }
26500                 protected:
26501                 template<typename V> bool decode(size_t index, V& v)
26502                 {
26503                         clear();
26504                         switch(index)
26505                         {
26506                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26507                         }
26508                         return false;
26509
26510                 }
26511                 template<typename V> bool encode(size_t index, V& v) const
26512                 {
26513                         if(index != type) return false;
26514                         return false;
26515
26516                 }
26517                 private:
26518                 size_t type {0};
26519
26520         };
26521         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26522         {
26523                 size_t get_index() const {return type;}
26524                 bool is_unknown() const { return type == 1; }
26525                 void clear() {type = 0;}
26526                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26527                 template<typename V>  bool decode(V& v)
26528                 {
26529                         clear();
26530                         if(!v(ref_nested())) return false;
26531                         { type = 1; return true;}
26532                         return false;
26533
26534                 }
26535                 template<typename V> bool encode(V& v) const
26536                 {
26537                         return v(ref_nested());
26538
26539                 }
26540                 protected:
26541                 template<typename V>  bool decode(size_t index, V& v)
26542                 {
26543                         clear();
26544                         switch(index)
26545                         {
26546                         case 1: type = 1; return v(ref_nested());
26547                         ref_nested().clear();
26548                         }
26549                         return false;
26550
26551                 }
26552                 template<typename V> bool encode(size_t index, V& v) const
26553                 {
26554                         if(index != type) {return false;} return v(ref_nested());
26555
26556                 }
26557                 private:
26558                 size_t type {0};
26559
26560         };
26561
26562 };
26563 /*
26564 E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
26565         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresentExtIEs} }   OPTIONAL,
26566         ...
26567 }
26568 */
26569
26570 struct E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
26571 {
26572         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent";}
26573         using parent_t = asn::sequence<1, 0, true, 1>;
26574         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>
26575         {
26576                 static constexpr const char* name() {return "iE_Extensions_t";}
26577                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresentExtIEs>;
26578                 static constexpr bool optional = true;
26579
26580         };
26581         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26582         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26583         template<typename V> void decode(V& v)
26584         {
26585                 v(iE_Extensions);
26586
26587         };
26588         template<typename V> void encode(V& v) const
26589         {
26590                 v(iE_Extensions);
26591
26592         };
26593         void clear()
26594         {
26595                 iE_Extensions.clear();
26596
26597         };
26598         private:
26599         iE_Extensions_t iE_Extensions;
26600
26601 };
26602 /*
26603 E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26604         ...
26605 }
26606 */
26607
26608 struct E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs
26609 {
26610         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26611         {
26612                 size_t get_index() const {return type;}
26613                 bool is_unknown() const { return type == 1; }
26614                 void clear() {type = 0;}
26615                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26616                 template<typename V>  bool decode(V& v)
26617                 {
26618                         clear();
26619                         if(!v(ref_nested())) return false;
26620                         { type = 1; return true;}
26621                         return false;
26622
26623                 }
26624                 template<typename V> bool encode(V& v) const
26625                 {
26626                         return v(ref_nested());
26627
26628                 }
26629                 protected:
26630                 template<typename V>  bool decode(size_t index, V& v)
26631                 {
26632                         clear();
26633                         switch(index)
26634                         {
26635                         case 1: type = 1; return v(ref_nested());
26636                         ref_nested().clear();
26637                         }
26638                         return false;
26639
26640                 }
26641                 template<typename V> bool encode(size_t index, V& v) const
26642                 {
26643                         if(index != type) {return false;} return v(ref_nested());
26644
26645                 }
26646                 private:
26647                 size_t type {0};
26648
26649         };
26650         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26651         {
26652                 size_t get_index() const {return type;}
26653                 bool is_unknown() const { return type == 1; }
26654                 void clear() {type = 0;}
26655                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26656                 template<typename V>  bool decode(V& v)
26657                 {
26658                         clear();
26659                         if(!v(ref_nested())) return false;
26660                         { type = 1; return true;}
26661                         return false;
26662
26663                 }
26664                 template<typename V> bool encode(V& v) const
26665                 {
26666                         return v(ref_nested());
26667
26668                 }
26669                 protected:
26670                 template<typename V>  bool decode(size_t index, V& v)
26671                 {
26672                         clear();
26673                         switch(index)
26674                         {
26675                         case 1: type = 1; return v(ref_nested());
26676                         ref_nested().clear();
26677                         }
26678                         return false;
26679
26680                 }
26681                 template<typename V> bool encode(size_t index, V& v) const
26682                 {
26683                         if(index != type) {return false;} return v(ref_nested());
26684
26685                 }
26686                 private:
26687                 size_t type {0};
26688
26689         };
26690         struct Extension_t : asn::typefield<true>
26691         {
26692                 ~Extension_t()  {clear();}
26693                 size_t get_index() const {return type;}
26694                 bool is_unknown() const { return type == 1; }
26695                 void clear()
26696                 {
26697                         type = 0; ref_nested().clear();
26698                 }
26699                 template<typename V> static inline void enumerate(V& v)
26700                 {
26701
26702                 }
26703                 protected:
26704                 template<typename V> bool decode(size_t index, V& v)
26705                 {
26706                         clear();
26707                         switch(index)
26708                         {
26709                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26710                         }
26711                         return false;
26712
26713                 }
26714                 template<typename V> bool encode(size_t index, V& v) const
26715                 {
26716                         if(index != type) return false;
26717                         return false;
26718
26719                 }
26720                 private:
26721                 size_t type {0};
26722
26723         };
26724         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26725         {
26726                 size_t get_index() const {return type;}
26727                 bool is_unknown() const { return type == 1; }
26728                 void clear() {type = 0;}
26729                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26730                 template<typename V>  bool decode(V& v)
26731                 {
26732                         clear();
26733                         if(!v(ref_nested())) return false;
26734                         { type = 1; return true;}
26735                         return false;
26736
26737                 }
26738                 template<typename V> bool encode(V& v) const
26739                 {
26740                         return v(ref_nested());
26741
26742                 }
26743                 protected:
26744                 template<typename V>  bool decode(size_t index, V& v)
26745                 {
26746                         clear();
26747                         switch(index)
26748                         {
26749                         case 1: type = 1; return v(ref_nested());
26750                         ref_nested().clear();
26751                         }
26752                         return false;
26753
26754                 }
26755                 template<typename V> bool encode(size_t index, V& v) const
26756                 {
26757                         if(index != type) {return false;} return v(ref_nested());
26758
26759                 }
26760                 private:
26761                 size_t type {0};
26762
26763         };
26764
26765 };
26766 /*
26767 E-RABs-ToBeReleased-SgNBModReq-Item ::= SEQUENCE {
26768         e-RAB-ID                                                                E-RAB-ID,
26769         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
26770         resource-configuration                          CHOICE {
26771                 sgNBPDCPpresent                                         E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPpresent,
26772                 sgNBPDCPnotpresent                                      E-RABs-ToBeReleased-SgNBModReq-Item-SgNBPDCPnotpresent,
26773                 ...
26774         },
26775         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReq-ItemExtIEs} }      OPTIONAL,
26776         ...
26777 }
26778 */
26779
26780 struct E_RABs_ToBeReleased_SgNBModReq_Item : asn::sequence<4, 0, true, 1>
26781 {
26782         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-Item";}
26783         using parent_t = asn::sequence<4, 0, true, 1>;
26784         struct e_RAB_ID_t : E_RAB_ID
26785         {
26786                 static constexpr const char* name() {return "e_RAB_ID_t";}
26787                 using parent_t = E_RAB_ID;
26788
26789         };
26790         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
26791         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
26792         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
26793         {
26794                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
26795                 using parent_t = EN_DC_ResourceConfiguration;
26796
26797         };
26798         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
26799         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
26800         struct resource_configuration_t : asn::choice<2, 0, true>
26801         {
26802                 static constexpr const char* name() {return "resource_configuration_t";}
26803                 using parent_t = asn::choice<2, 0, true>;
26804                 index_type get_index() const {return index;}
26805                 bool is_unknown() const {return index == 3;}
26806                 void set_unknown() { set_index(3);  }
26807                 ~resource_configuration_t() {clear();}
26808                 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent
26809                 {
26810                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
26811                         using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPpresent;
26812
26813                 };
26814                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent
26815                 {
26816                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
26817                         using parent_t = E_RABs_ToBeReleased_SgNBModReq_Item_SgNBPDCPnotpresent;
26818
26819                 };
26820                 void clear()
26821                 {
26822                         switch(get_index())
26823                         {
26824                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
26825                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
26826                         }
26827                         index = 0;
26828                         base::clear();
26829                 }
26830                 template<typename V> bool decode(size_t idx, V& v)
26831                 {
26832                         clear();
26833                         switch(idx)
26834                         {
26835                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
26836                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
26837                         }
26838                         return false;
26839
26840                 }
26841                 template<typename V> bool encode(V& v) const
26842                 {
26843                         switch(get_index())
26844                         {
26845                         case 1: return v(var.as<sgNBPDCPpresent_t>());
26846                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
26847                         }
26848                         return false;
26849                 }
26850                 template<typename V> static inline void enumerate(V& v)
26851                 {
26852                         v.template operator()<sgNBPDCPpresent_t>(1);
26853                         v.template operator()<sgNBPDCPnotpresent_t>(2);
26854
26855                 }
26856                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
26857                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
26858                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
26859                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
26860                 private:
26861                 void set_index(index_type i) {index = i; base::set();}
26862                 union union_type
26863                 {
26864                         char dummy1[sizeof(sgNBPDCPpresent_t)];
26865                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
26866
26867                 };
26868                 asn::variant<sizeof(union_type)>        var;
26869                 index_type      index {0};
26870         };
26871         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
26872         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
26873         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>
26874         {
26875                 static constexpr const char* name() {return "iE_Extensions_t";}
26876                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReq_ItemExtIEs>;
26877                 static constexpr bool optional = true;
26878
26879         };
26880         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26881         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26882         template<typename V> void decode(V& v)
26883         {
26884                 v(e_RAB_ID);
26885                 v(en_DC_ResourceConfiguration);
26886                 v(resource_configuration);
26887                 v(iE_Extensions);
26888
26889         };
26890         template<typename V> void encode(V& v) const
26891         {
26892                 v(e_RAB_ID);
26893                 v(en_DC_ResourceConfiguration);
26894                 v(resource_configuration);
26895                 v(iE_Extensions);
26896
26897         };
26898         void clear()
26899         {
26900                 e_RAB_ID.clear();
26901                 en_DC_ResourceConfiguration.clear();
26902                 resource_configuration.clear();
26903                 iE_Extensions.clear();
26904
26905         };
26906         private:
26907         e_RAB_ID_t      e_RAB_ID;
26908         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
26909         resource_configuration_t        resource_configuration;
26910         iE_Extensions_t iE_Extensions;
26911
26912 };
26913 /*
26914 E-RABs-ToBeReleased-SgNBModReq-ItemIEs X2AP-PROTOCOL-IES ::= {
26915         { ID id-E-RABs-ToBeReleased-SgNBModReq-Item     CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBModReq-Item                PRESENCE mandatory},
26916         ...
26917 }
26918 */
26919
26920 struct E_RABs_ToBeReleased_SgNBModReq_ItemIEs
26921 {
26922         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
26923         {
26924                 size_t get_index() const {return type;}
26925                 bool is_unknown() const { return type == 2; }
26926                 void clear() {type = 0;}
26927                 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(id_E_RABs_ToBeReleased_SgNBModReq_Item); type=1;}
26928                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
26929                 template<typename V>  bool decode(V& v)
26930                 {
26931                         clear();
26932                         if(!v(ref_nested())) return false;
26933                         if(equal(id_E_RABs_ToBeReleased_SgNBModReq_Item)) { type = 1; return true; }
26934                         else { type = 2; return true;}
26935                         return false;
26936
26937                 }
26938                 template<typename V> bool encode(V& v) const
26939                 {
26940                         return v(ref_nested());
26941
26942                 }
26943                 protected:
26944                 template<typename V>  bool decode(size_t index, V& v)
26945                 {
26946                         clear();
26947                         switch(index)
26948                         {
26949                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReq_Item);} return false;
26950                         case 2: type = 2; return v(ref_nested());
26951                         ref_nested().clear();
26952                         }
26953                         return false;
26954
26955                 }
26956                 template<typename V> bool encode(size_t index, V& v) const
26957                 {
26958                         if(index != type) {return false;} return v(ref_nested());
26959
26960                 }
26961                 private:
26962                 size_t type {0};
26963
26964         };
26965         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
26966         {
26967                 size_t get_index() const {return type;}
26968                 bool is_unknown() const { return type == 2; }
26969                 void clear() {type = 0;}
26970                 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(ignore); type=1;}
26971                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
26972                 template<typename V>  bool decode(V& v)
26973                 {
26974                         clear();
26975                         if(!v(ref_nested())) return false;
26976                         if(equal(ignore)) { type = 1; return true; }
26977                         else { type = 2; return true;}
26978                         return false;
26979
26980                 }
26981                 template<typename V> bool encode(V& v) const
26982                 {
26983                         return v(ref_nested());
26984
26985                 }
26986                 protected:
26987                 template<typename V>  bool decode(size_t index, V& v)
26988                 {
26989                         clear();
26990                         switch(index)
26991                         {
26992                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26993                         case 2: type = 2; return v(ref_nested());
26994                         ref_nested().clear();
26995                         }
26996                         return false;
26997
26998                 }
26999                 template<typename V> bool encode(size_t index, V& v) const
27000                 {
27001                         if(index != type) {return false;} return v(ref_nested());
27002
27003                 }
27004                 private:
27005                 size_t type {0};
27006
27007         };
27008         struct Value_t : asn::typefield<true>
27009         {
27010                 ~Value_t()      {clear();}
27011                 size_t get_index() const {return type;}
27012                 E_RABs_ToBeReleased_SgNBModReq_Item& select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { return set<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
27013                 E_RABs_ToBeReleased_SgNBModReq_Item const* get_id_E_RABs_ToBeReleased_SgNBModReq_Item() const { return get<E_RABs_ToBeReleased_SgNBModReq_Item>(1); }
27014                 bool is_unknown() const { return type == 2; }
27015                 void clear()
27016                 {
27017                         switch(type)
27018                         {
27019                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReq_Item>(); break;
27020                         }
27021                         type = 0; ref_nested().clear();
27022                 }
27023                 template<typename V> static inline void enumerate(V& v)
27024                 {
27025                         v.template operator()<E_RABs_ToBeReleased_SgNBModReq_Item>(1);
27026
27027                 }
27028                 protected:
27029                 template<typename V> bool decode(size_t index, V& v)
27030                 {
27031                         clear();
27032                         switch(index)
27033                         {
27034                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReq_Item()); return true;
27035                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27036                         }
27037                         return false;
27038
27039                 }
27040                 template<typename V> bool encode(size_t index, V& v) const
27041                 {
27042                         if(index != type) return false;
27043                         switch(type)
27044                         {
27045                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBModReq_Item>()); return true;
27046                         }
27047                         return false;
27048
27049                 }
27050                 private:
27051                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27052                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27053                 union union_type
27054                 {
27055                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBModReq_Item)];
27056
27057                 };
27058                 asn::variant<sizeof(union_type)> var;
27059                 size_t type {0};
27060
27061         };
27062         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
27063         {
27064                 size_t get_index() const {return type;}
27065                 bool is_unknown() const { return type == 2; }
27066                 void clear() {type = 0;}
27067                 void select_id_E_RABs_ToBeReleased_SgNBModReq_Item() { set(mandatory); type=1;}
27068                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
27069                 template<typename V>  bool decode(V& v)
27070                 {
27071                         clear();
27072                         if(!v(ref_nested())) return false;
27073                         if(equal(mandatory)) { type = 1; return true; }
27074                         else { type = 2; return true;}
27075                         return false;
27076
27077                 }
27078                 template<typename V> bool encode(V& v) const
27079                 {
27080                         return v(ref_nested());
27081
27082                 }
27083                 protected:
27084                 template<typename V>  bool decode(size_t index, V& v)
27085                 {
27086                         clear();
27087                         switch(index)
27088                         {
27089                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
27090                         case 2: type = 2; return v(ref_nested());
27091                         ref_nested().clear();
27092                         }
27093                         return false;
27094
27095                 }
27096                 template<typename V> bool encode(size_t index, V& v) const
27097                 {
27098                         if(index != type) {return false;} return v(ref_nested());
27099
27100                 }
27101                 private:
27102                 size_t type {0};
27103
27104         };
27105
27106 };
27107 /*
27108 E-RABs-ToBeReleased-SgNBModReq-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReq-ItemIEs} }
27109 */
27110
27111 struct E_RABs_ToBeReleased_SgNBModReq_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>
27112 {
27113         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReq_List_elm";}
27114         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReq_ItemIEs>;
27115
27116 };
27117 struct E_RABs_ToBeReleased_SgNBModReq_List : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>
27118 {
27119         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReq-List";}
27120         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReq_List_elm>;
27121         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
27122
27123 };
27124 /*
27125 E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27126         { ID id-RLCMode-transferred                                     CRITICALITY ignore      EXTENSION RLCMode                                       PRESENCE optional},
27127         ...
27128 }
27129 */
27130
27131 struct E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs
27132 {
27133         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27134         {
27135                 size_t get_index() const {return type;}
27136                 bool is_unknown() const { return type == 2; }
27137                 void clear() {type = 0;}
27138                 void select_id_RLCMode_transferred() { set(id_RLCMode_transferred); type=1;}
27139                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27140                 template<typename V>  bool decode(V& v)
27141                 {
27142                         clear();
27143                         if(!v(ref_nested())) return false;
27144                         if(equal(id_RLCMode_transferred)) { type = 1; return true; }
27145                         else { type = 2; return true;}
27146                         return false;
27147
27148                 }
27149                 template<typename V> bool encode(V& v) const
27150                 {
27151                         return v(ref_nested());
27152
27153                 }
27154                 protected:
27155                 template<typename V>  bool decode(size_t index, V& v)
27156                 {
27157                         clear();
27158                         switch(index)
27159                         {
27160                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RLCMode_transferred);} return false;
27161                         case 2: type = 2; return v(ref_nested());
27162                         ref_nested().clear();
27163                         }
27164                         return false;
27165
27166                 }
27167                 template<typename V> bool encode(size_t index, V& v) const
27168                 {
27169                         if(index != type) {return false;} return v(ref_nested());
27170
27171                 }
27172                 private:
27173                 size_t type {0};
27174
27175         };
27176         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27177         {
27178                 size_t get_index() const {return type;}
27179                 bool is_unknown() const { return type == 2; }
27180                 void clear() {type = 0;}
27181                 void select_id_RLCMode_transferred() { set(ignore); type=1;}
27182                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27183                 template<typename V>  bool decode(V& v)
27184                 {
27185                         clear();
27186                         if(!v(ref_nested())) return false;
27187                         if(equal(ignore)) { type = 1; return true; }
27188                         else { type = 2; return true;}
27189                         return false;
27190
27191                 }
27192                 template<typename V> bool encode(V& v) const
27193                 {
27194                         return v(ref_nested());
27195
27196                 }
27197                 protected:
27198                 template<typename V>  bool decode(size_t index, V& v)
27199                 {
27200                         clear();
27201                         switch(index)
27202                         {
27203                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27204                         case 2: type = 2; return v(ref_nested());
27205                         ref_nested().clear();
27206                         }
27207                         return false;
27208
27209                 }
27210                 template<typename V> bool encode(size_t index, V& v) const
27211                 {
27212                         if(index != type) {return false;} return v(ref_nested());
27213
27214                 }
27215                 private:
27216                 size_t type {0};
27217
27218         };
27219         struct Extension_t : asn::typefield<true>
27220         {
27221                 ~Extension_t()  {clear();}
27222                 size_t get_index() const {return type;}
27223                 RLCMode& select_id_RLCMode_transferred() { return set<RLCMode>(1); }
27224                 RLCMode const* get_id_RLCMode_transferred() const { return get<RLCMode>(1); }
27225                 bool is_unknown() const { return type == 2; }
27226                 void clear()
27227                 {
27228                         switch(type)
27229                         {
27230                         case 1: var.destroy<RLCMode>(); break;
27231                         }
27232                         type = 0; ref_nested().clear();
27233                 }
27234                 template<typename V> static inline void enumerate(V& v)
27235                 {
27236                         v.template operator()<RLCMode>(1);
27237
27238                 }
27239                 protected:
27240                 template<typename V> bool decode(size_t index, V& v)
27241                 {
27242                         clear();
27243                         switch(index)
27244                         {
27245                         case 1: v(select_id_RLCMode_transferred()); return true;
27246                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27247                         }
27248                         return false;
27249
27250                 }
27251                 template<typename V> bool encode(size_t index, V& v) const
27252                 {
27253                         if(index != type) return false;
27254                         switch(type)
27255                         {
27256                         case 1: v(var.as<RLCMode>()); return true;
27257                         }
27258                         return false;
27259
27260                 }
27261                 private:
27262                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27263                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27264                 union union_type
27265                 {
27266                         char dummy1[sizeof(RLCMode)];
27267
27268                 };
27269                 asn::variant<sizeof(union_type)> var;
27270                 size_t type {0};
27271
27272         };
27273         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27274         {
27275                 size_t get_index() const {return type;}
27276                 bool is_unknown() const { return type == 2; }
27277                 void clear() {type = 0;}
27278                 void select_id_RLCMode_transferred() { set(optional); type=1;}
27279                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27280                 template<typename V>  bool decode(V& v)
27281                 {
27282                         clear();
27283                         if(!v(ref_nested())) return false;
27284                         if(equal(optional)) { type = 1; return true; }
27285                         else { type = 2; return true;}
27286                         return false;
27287
27288                 }
27289                 template<typename V> bool encode(V& v) const
27290                 {
27291                         return v(ref_nested());
27292
27293                 }
27294                 protected:
27295                 template<typename V>  bool decode(size_t index, V& v)
27296                 {
27297                         clear();
27298                         switch(index)
27299                         {
27300                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
27301                         case 2: type = 2; return v(ref_nested());
27302                         ref_nested().clear();
27303                         }
27304                         return false;
27305
27306                 }
27307                 template<typename V> bool encode(size_t index, V& v) const
27308                 {
27309                         if(index != type) {return false;} return v(ref_nested());
27310
27311                 }
27312                 private:
27313                 size_t type {0};
27314
27315         };
27316
27317 };
27318 /*
27319 E-RABs-ToBeReleased-SgNBModReqd-Item ::= SEQUENCE {
27320         e-RAB-ID                                                        E-RAB-ID,
27321         cause                                                   Cause,
27322         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBModReqd-ItemExtIEs} } OPTIONAL,
27323         ...
27324 }
27325 */
27326
27327 struct E_RABs_ToBeReleased_SgNBModReqd_Item : asn::sequence<3, 0, true, 1>
27328 {
27329         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqd-Item";}
27330         using parent_t = asn::sequence<3, 0, true, 1>;
27331         struct e_RAB_ID_t : E_RAB_ID
27332         {
27333                 static constexpr const char* name() {return "e_RAB_ID_t";}
27334                 using parent_t = E_RAB_ID;
27335
27336         };
27337         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
27338         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
27339         struct cause_t : Cause
27340         {
27341                 static constexpr const char* name() {return "cause_t";}
27342                 using parent_t = Cause;
27343
27344         };
27345         cause_t& ref_cause() {return cause;}
27346         cause_t const& ref_cause() const {return cause;}
27347         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>
27348         {
27349                 static constexpr const char* name() {return "iE_Extensions_t";}
27350                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBModReqd_ItemExtIEs>;
27351                 static constexpr bool optional = true;
27352
27353         };
27354         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27355         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27356         template<typename V> void decode(V& v)
27357         {
27358                 v(e_RAB_ID);
27359                 v(cause);
27360                 v(iE_Extensions);
27361
27362         };
27363         template<typename V> void encode(V& v) const
27364         {
27365                 v(e_RAB_ID);
27366                 v(cause);
27367                 v(iE_Extensions);
27368
27369         };
27370         void clear()
27371         {
27372                 e_RAB_ID.clear();
27373                 cause.clear();
27374                 iE_Extensions.clear();
27375
27376         };
27377         private:
27378         e_RAB_ID_t      e_RAB_ID;
27379         cause_t cause;
27380         iE_Extensions_t iE_Extensions;
27381
27382 };
27383 /*
27384 E-RABs-ToBeReleased-SgNBModReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
27385         { ID id-E-RABs-ToBeReleased-SgNBModReqd-Item     CRITICALITY ignore             TYPE E-RABs-ToBeReleased-SgNBModReqd-Item               PRESENCE mandatory },
27386         ...
27387 }
27388 */
27389
27390 struct E_RABs_ToBeReleased_SgNBModReqd_ItemIEs
27391 {
27392         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
27393         {
27394                 size_t get_index() const {return type;}
27395                 bool is_unknown() const { return type == 2; }
27396                 void clear() {type = 0;}
27397                 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBModReqd_Item); type=1;}
27398                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
27399                 template<typename V>  bool decode(V& v)
27400                 {
27401                         clear();
27402                         if(!v(ref_nested())) return false;
27403                         if(equal(id_E_RABs_ToBeReleased_SgNBModReqd_Item)) { type = 1; return true; }
27404                         else { type = 2; return true;}
27405                         return false;
27406
27407                 }
27408                 template<typename V> bool encode(V& v) const
27409                 {
27410                         return v(ref_nested());
27411
27412                 }
27413                 protected:
27414                 template<typename V>  bool decode(size_t index, V& v)
27415                 {
27416                         clear();
27417                         switch(index)
27418                         {
27419                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReqd_Item);} return false;
27420                         case 2: type = 2; return v(ref_nested());
27421                         ref_nested().clear();
27422                         }
27423                         return false;
27424
27425                 }
27426                 template<typename V> bool encode(size_t index, V& v) const
27427                 {
27428                         if(index != type) {return false;} return v(ref_nested());
27429
27430                 }
27431                 private:
27432                 size_t type {0};
27433
27434         };
27435         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
27436         {
27437                 size_t get_index() const {return type;}
27438                 bool is_unknown() const { return type == 2; }
27439                 void clear() {type = 0;}
27440                 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(ignore); type=1;}
27441                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
27442                 template<typename V>  bool decode(V& v)
27443                 {
27444                         clear();
27445                         if(!v(ref_nested())) return false;
27446                         if(equal(ignore)) { type = 1; return true; }
27447                         else { type = 2; return true;}
27448                         return false;
27449
27450                 }
27451                 template<typename V> bool encode(V& v) const
27452                 {
27453                         return v(ref_nested());
27454
27455                 }
27456                 protected:
27457                 template<typename V>  bool decode(size_t index, V& v)
27458                 {
27459                         clear();
27460                         switch(index)
27461                         {
27462                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27463                         case 2: type = 2; return v(ref_nested());
27464                         ref_nested().clear();
27465                         }
27466                         return false;
27467
27468                 }
27469                 template<typename V> bool encode(size_t index, V& v) const
27470                 {
27471                         if(index != type) {return false;} return v(ref_nested());
27472
27473                 }
27474                 private:
27475                 size_t type {0};
27476
27477         };
27478         struct Value_t : asn::typefield<true>
27479         {
27480                 ~Value_t()      {clear();}
27481                 size_t get_index() const {return type;}
27482                 E_RABs_ToBeReleased_SgNBModReqd_Item& select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { return set<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
27483                 E_RABs_ToBeReleased_SgNBModReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBModReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBModReqd_Item>(1); }
27484                 bool is_unknown() const { return type == 2; }
27485                 void clear()
27486                 {
27487                         switch(type)
27488                         {
27489                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBModReqd_Item>(); break;
27490                         }
27491                         type = 0; ref_nested().clear();
27492                 }
27493                 template<typename V> static inline void enumerate(V& v)
27494                 {
27495                         v.template operator()<E_RABs_ToBeReleased_SgNBModReqd_Item>(1);
27496
27497                 }
27498                 protected:
27499                 template<typename V> bool decode(size_t index, V& v)
27500                 {
27501                         clear();
27502                         switch(index)
27503                         {
27504                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBModReqd_Item()); return true;
27505                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27506                         }
27507                         return false;
27508
27509                 }
27510                 template<typename V> bool encode(size_t index, V& v) const
27511                 {
27512                         if(index != type) return false;
27513                         switch(type)
27514                         {
27515                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBModReqd_Item>()); return true;
27516                         }
27517                         return false;
27518
27519                 }
27520                 private:
27521                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27522                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27523                 union union_type
27524                 {
27525                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBModReqd_Item)];
27526
27527                 };
27528                 asn::variant<sizeof(union_type)> var;
27529                 size_t type {0};
27530
27531         };
27532         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
27533         {
27534                 size_t get_index() const {return type;}
27535                 bool is_unknown() const { return type == 2; }
27536                 void clear() {type = 0;}
27537                 void select_id_E_RABs_ToBeReleased_SgNBModReqd_Item() { set(mandatory); type=1;}
27538                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
27539                 template<typename V>  bool decode(V& v)
27540                 {
27541                         clear();
27542                         if(!v(ref_nested())) return false;
27543                         if(equal(mandatory)) { type = 1; return true; }
27544                         else { type = 2; return true;}
27545                         return false;
27546
27547                 }
27548                 template<typename V> bool encode(V& v) const
27549                 {
27550                         return v(ref_nested());
27551
27552                 }
27553                 protected:
27554                 template<typename V>  bool decode(size_t index, V& v)
27555                 {
27556                         clear();
27557                         switch(index)
27558                         {
27559                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
27560                         case 2: type = 2; return v(ref_nested());
27561                         ref_nested().clear();
27562                         }
27563                         return false;
27564
27565                 }
27566                 template<typename V> bool encode(size_t index, V& v) const
27567                 {
27568                         if(index != type) {return false;} return v(ref_nested());
27569
27570                 }
27571                 private:
27572                 size_t type {0};
27573
27574         };
27575
27576 };
27577 /*
27578 E-RABs-ToBeReleased-SgNBModReqdList ::= SEQUENCE (SIZE (1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBModReqd-ItemIEs} }
27579 */
27580
27581 struct E_RABs_ToBeReleased_SgNBModReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>
27582 {
27583         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBModReqdList_elm";}
27584         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBModReqd_ItemIEs>;
27585
27586 };
27587 struct E_RABs_ToBeReleased_SgNBModReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>
27588 {
27589         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBModReqdList";}
27590         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBModReqdList_elm>;
27591         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
27592
27593 };
27594 /*
27595 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27596         ...
27597 }
27598 */
27599
27600 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs
27601 {
27602         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27603         {
27604                 size_t get_index() const {return type;}
27605                 bool is_unknown() const { return type == 1; }
27606                 void clear() {type = 0;}
27607                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27608                 template<typename V>  bool decode(V& v)
27609                 {
27610                         clear();
27611                         if(!v(ref_nested())) return false;
27612                         { type = 1; return true;}
27613                         return false;
27614
27615                 }
27616                 template<typename V> bool encode(V& v) const
27617                 {
27618                         return v(ref_nested());
27619
27620                 }
27621                 protected:
27622                 template<typename V>  bool decode(size_t index, V& v)
27623                 {
27624                         clear();
27625                         switch(index)
27626                         {
27627                         case 1: type = 1; return v(ref_nested());
27628                         ref_nested().clear();
27629                         }
27630                         return false;
27631
27632                 }
27633                 template<typename V> bool encode(size_t index, V& v) const
27634                 {
27635                         if(index != type) {return false;} return v(ref_nested());
27636
27637                 }
27638                 private:
27639                 size_t type {0};
27640
27641         };
27642         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27643         {
27644                 size_t get_index() const {return type;}
27645                 bool is_unknown() const { return type == 1; }
27646                 void clear() {type = 0;}
27647                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27648                 template<typename V>  bool decode(V& v)
27649                 {
27650                         clear();
27651                         if(!v(ref_nested())) return false;
27652                         { type = 1; return true;}
27653                         return false;
27654
27655                 }
27656                 template<typename V> bool encode(V& v) const
27657                 {
27658                         return v(ref_nested());
27659
27660                 }
27661                 protected:
27662                 template<typename V>  bool decode(size_t index, V& v)
27663                 {
27664                         clear();
27665                         switch(index)
27666                         {
27667                         case 1: type = 1; return v(ref_nested());
27668                         ref_nested().clear();
27669                         }
27670                         return false;
27671
27672                 }
27673                 template<typename V> bool encode(size_t index, V& v) const
27674                 {
27675                         if(index != type) {return false;} return v(ref_nested());
27676
27677                 }
27678                 private:
27679                 size_t type {0};
27680
27681         };
27682         struct Extension_t : asn::typefield<true>
27683         {
27684                 ~Extension_t()  {clear();}
27685                 size_t get_index() const {return type;}
27686                 bool is_unknown() const { return type == 1; }
27687                 void clear()
27688                 {
27689                         type = 0; ref_nested().clear();
27690                 }
27691                 template<typename V> static inline void enumerate(V& v)
27692                 {
27693
27694                 }
27695                 protected:
27696                 template<typename V> bool decode(size_t index, V& v)
27697                 {
27698                         clear();
27699                         switch(index)
27700                         {
27701                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27702                         }
27703                         return false;
27704
27705                 }
27706                 template<typename V> bool encode(size_t index, V& v) const
27707                 {
27708                         if(index != type) return false;
27709                         return false;
27710
27711                 }
27712                 private:
27713                 size_t type {0};
27714
27715         };
27716         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27717         {
27718                 size_t get_index() const {return type;}
27719                 bool is_unknown() const { return type == 1; }
27720                 void clear() {type = 0;}
27721                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27722                 template<typename V>  bool decode(V& v)
27723                 {
27724                         clear();
27725                         if(!v(ref_nested())) return false;
27726                         { type = 1; return true;}
27727                         return false;
27728
27729                 }
27730                 template<typename V> bool encode(V& v) const
27731                 {
27732                         return v(ref_nested());
27733
27734                 }
27735                 protected:
27736                 template<typename V>  bool decode(size_t index, V& v)
27737                 {
27738                         clear();
27739                         switch(index)
27740                         {
27741                         case 1: type = 1; return v(ref_nested());
27742                         ref_nested().clear();
27743                         }
27744                         return false;
27745
27746                 }
27747                 template<typename V> bool encode(size_t index, V& v) const
27748                 {
27749                         if(index != type) {return false;} return v(ref_nested());
27750
27751                 }
27752                 private:
27753                 size_t type {0};
27754
27755         };
27756
27757 };
27758 /*
27759 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent ::= SEQUENCE {
27760         uL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
27761         dL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
27762         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresentExtIEs} } OPTIONAL,
27763         ...
27764 }
27765 */
27766
27767 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
27768 {
27769         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent";}
27770         using parent_t = asn::sequence<3, 0, true, 3>;
27771         struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
27772         {
27773                 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
27774                 using parent_t = GTPtunnelEndpoint;
27775                 static constexpr bool optional = true;
27776
27777         };
27778         uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
27779         uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
27780         struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
27781         {
27782                 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
27783                 using parent_t = GTPtunnelEndpoint;
27784                 static constexpr bool optional = true;
27785
27786         };
27787         dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
27788         dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
27789         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>
27790         {
27791                 static constexpr const char* name() {return "iE_Extensions_t";}
27792                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresentExtIEs>;
27793                 static constexpr bool optional = true;
27794
27795         };
27796         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27797         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27798         template<typename V> void decode(V& v)
27799         {
27800                 v(uL_GTPtunnelEndpoint);
27801                 v(dL_GTPtunnelEndpoint);
27802                 v(iE_Extensions);
27803
27804         };
27805         template<typename V> void encode(V& v) const
27806         {
27807                 v(uL_GTPtunnelEndpoint);
27808                 v(dL_GTPtunnelEndpoint);
27809                 v(iE_Extensions);
27810
27811         };
27812         void clear()
27813         {
27814                 uL_GTPtunnelEndpoint.clear();
27815                 dL_GTPtunnelEndpoint.clear();
27816                 iE_Extensions.clear();
27817
27818         };
27819         private:
27820         uL_GTPtunnelEndpoint_t  uL_GTPtunnelEndpoint;
27821         dL_GTPtunnelEndpoint_t  dL_GTPtunnelEndpoint;
27822         iE_Extensions_t iE_Extensions;
27823
27824 };
27825 /*
27826 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27827         ...
27828 }
27829 */
27830
27831 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs
27832 {
27833         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27834         {
27835                 size_t get_index() const {return type;}
27836                 bool is_unknown() const { return type == 1; }
27837                 void clear() {type = 0;}
27838                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27839                 template<typename V>  bool decode(V& v)
27840                 {
27841                         clear();
27842                         if(!v(ref_nested())) return false;
27843                         { type = 1; return true;}
27844                         return false;
27845
27846                 }
27847                 template<typename V> bool encode(V& v) const
27848                 {
27849                         return v(ref_nested());
27850
27851                 }
27852                 protected:
27853                 template<typename V>  bool decode(size_t index, V& v)
27854                 {
27855                         clear();
27856                         switch(index)
27857                         {
27858                         case 1: type = 1; return v(ref_nested());
27859                         ref_nested().clear();
27860                         }
27861                         return false;
27862
27863                 }
27864                 template<typename V> bool encode(size_t index, V& v) const
27865                 {
27866                         if(index != type) {return false;} return v(ref_nested());
27867
27868                 }
27869                 private:
27870                 size_t type {0};
27871
27872         };
27873         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27874         {
27875                 size_t get_index() const {return type;}
27876                 bool is_unknown() const { return type == 1; }
27877                 void clear() {type = 0;}
27878                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27879                 template<typename V>  bool decode(V& v)
27880                 {
27881                         clear();
27882                         if(!v(ref_nested())) return false;
27883                         { type = 1; return true;}
27884                         return false;
27885
27886                 }
27887                 template<typename V> bool encode(V& v) const
27888                 {
27889                         return v(ref_nested());
27890
27891                 }
27892                 protected:
27893                 template<typename V>  bool decode(size_t index, V& v)
27894                 {
27895                         clear();
27896                         switch(index)
27897                         {
27898                         case 1: type = 1; return v(ref_nested());
27899                         ref_nested().clear();
27900                         }
27901                         return false;
27902
27903                 }
27904                 template<typename V> bool encode(size_t index, V& v) const
27905                 {
27906                         if(index != type) {return false;} return v(ref_nested());
27907
27908                 }
27909                 private:
27910                 size_t type {0};
27911
27912         };
27913         struct Extension_t : asn::typefield<true>
27914         {
27915                 ~Extension_t()  {clear();}
27916                 size_t get_index() const {return type;}
27917                 bool is_unknown() const { return type == 1; }
27918                 void clear()
27919                 {
27920                         type = 0; ref_nested().clear();
27921                 }
27922                 template<typename V> static inline void enumerate(V& v)
27923                 {
27924
27925                 }
27926                 protected:
27927                 template<typename V> bool decode(size_t index, V& v)
27928                 {
27929                         clear();
27930                         switch(index)
27931                         {
27932                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27933                         }
27934                         return false;
27935
27936                 }
27937                 template<typename V> bool encode(size_t index, V& v) const
27938                 {
27939                         if(index != type) return false;
27940                         return false;
27941
27942                 }
27943                 private:
27944                 size_t type {0};
27945
27946         };
27947         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27948         {
27949                 size_t get_index() const {return type;}
27950                 bool is_unknown() const { return type == 1; }
27951                 void clear() {type = 0;}
27952                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27953                 template<typename V>  bool decode(V& v)
27954                 {
27955                         clear();
27956                         if(!v(ref_nested())) return false;
27957                         { type = 1; return true;}
27958                         return false;
27959
27960                 }
27961                 template<typename V> bool encode(V& v) const
27962                 {
27963                         return v(ref_nested());
27964
27965                 }
27966                 protected:
27967                 template<typename V>  bool decode(size_t index, V& v)
27968                 {
27969                         clear();
27970                         switch(index)
27971                         {
27972                         case 1: type = 1; return v(ref_nested());
27973                         ref_nested().clear();
27974                         }
27975                         return false;
27976
27977                 }
27978                 template<typename V> bool encode(size_t index, V& v) const
27979                 {
27980                         if(index != type) {return false;} return v(ref_nested());
27981
27982                 }
27983                 private:
27984                 size_t type {0};
27985
27986         };
27987
27988 };
27989 /*
27990 E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent ::= SEQUENCE {
27991         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresentExtIEs} }  OPTIONAL,
27992         ...
27993 }
27994 */
27995
27996 struct E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
27997 {
27998         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent";}
27999         using parent_t = asn::sequence<1, 0, true, 1>;
28000         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>
28001         {
28002                 static constexpr const char* name() {return "iE_Extensions_t";}
28003                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresentExtIEs>;
28004                 static constexpr bool optional = true;
28005
28006         };
28007         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28008         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28009         template<typename V> void decode(V& v)
28010         {
28011                 v(iE_Extensions);
28012
28013         };
28014         template<typename V> void encode(V& v) const
28015         {
28016                 v(iE_Extensions);
28017
28018         };
28019         void clear()
28020         {
28021                 iE_Extensions.clear();
28022
28023         };
28024         private:
28025         iE_Extensions_t iE_Extensions;
28026
28027 };
28028 /*
28029 E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28030         ...
28031 }
28032 */
28033
28034 struct E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs
28035 {
28036         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28037         {
28038                 size_t get_index() const {return type;}
28039                 bool is_unknown() const { return type == 1; }
28040                 void clear() {type = 0;}
28041                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28042                 template<typename V>  bool decode(V& v)
28043                 {
28044                         clear();
28045                         if(!v(ref_nested())) return false;
28046                         { type = 1; return true;}
28047                         return false;
28048
28049                 }
28050                 template<typename V> bool encode(V& v) const
28051                 {
28052                         return v(ref_nested());
28053
28054                 }
28055                 protected:
28056                 template<typename V>  bool decode(size_t index, V& v)
28057                 {
28058                         clear();
28059                         switch(index)
28060                         {
28061                         case 1: type = 1; return v(ref_nested());
28062                         ref_nested().clear();
28063                         }
28064                         return false;
28065
28066                 }
28067                 template<typename V> bool encode(size_t index, V& v) const
28068                 {
28069                         if(index != type) {return false;} return v(ref_nested());
28070
28071                 }
28072                 private:
28073                 size_t type {0};
28074
28075         };
28076         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28077         {
28078                 size_t get_index() const {return type;}
28079                 bool is_unknown() const { return type == 1; }
28080                 void clear() {type = 0;}
28081                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28082                 template<typename V>  bool decode(V& v)
28083                 {
28084                         clear();
28085                         if(!v(ref_nested())) return false;
28086                         { type = 1; return true;}
28087                         return false;
28088
28089                 }
28090                 template<typename V> bool encode(V& v) const
28091                 {
28092                         return v(ref_nested());
28093
28094                 }
28095                 protected:
28096                 template<typename V>  bool decode(size_t index, V& v)
28097                 {
28098                         clear();
28099                         switch(index)
28100                         {
28101                         case 1: type = 1; return v(ref_nested());
28102                         ref_nested().clear();
28103                         }
28104                         return false;
28105
28106                 }
28107                 template<typename V> bool encode(size_t index, V& v) const
28108                 {
28109                         if(index != type) {return false;} return v(ref_nested());
28110
28111                 }
28112                 private:
28113                 size_t type {0};
28114
28115         };
28116         struct Extension_t : asn::typefield<true>
28117         {
28118                 ~Extension_t()  {clear();}
28119                 size_t get_index() const {return type;}
28120                 bool is_unknown() const { return type == 1; }
28121                 void clear()
28122                 {
28123                         type = 0; ref_nested().clear();
28124                 }
28125                 template<typename V> static inline void enumerate(V& v)
28126                 {
28127
28128                 }
28129                 protected:
28130                 template<typename V> bool decode(size_t index, V& v)
28131                 {
28132                         clear();
28133                         switch(index)
28134                         {
28135                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28136                         }
28137                         return false;
28138
28139                 }
28140                 template<typename V> bool encode(size_t index, V& v) const
28141                 {
28142                         if(index != type) return false;
28143                         return false;
28144
28145                 }
28146                 private:
28147                 size_t type {0};
28148
28149         };
28150         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28151         {
28152                 size_t get_index() const {return type;}
28153                 bool is_unknown() const { return type == 1; }
28154                 void clear() {type = 0;}
28155                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28156                 template<typename V>  bool decode(V& v)
28157                 {
28158                         clear();
28159                         if(!v(ref_nested())) return false;
28160                         { type = 1; return true;}
28161                         return false;
28162
28163                 }
28164                 template<typename V> bool encode(V& v) const
28165                 {
28166                         return v(ref_nested());
28167
28168                 }
28169                 protected:
28170                 template<typename V>  bool decode(size_t index, V& v)
28171                 {
28172                         clear();
28173                         switch(index)
28174                         {
28175                         case 1: type = 1; return v(ref_nested());
28176                         ref_nested().clear();
28177                         }
28178                         return false;
28179
28180                 }
28181                 template<typename V> bool encode(size_t index, V& v) const
28182                 {
28183                         if(index != type) {return false;} return v(ref_nested());
28184
28185                 }
28186                 private:
28187                 size_t type {0};
28188
28189         };
28190
28191 };
28192 /*
28193 E-RABs-ToBeReleased-SgNBRelConf-Item ::= SEQUENCE {
28194         e-RAB-ID                                                        E-RAB-ID,
28195         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
28196         resource-configuration                          CHOICE {
28197                 sgNBPDCPpresent                                         E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPpresent,
28198                 sgNBPDCPnotpresent                                      E-RABs-ToBeReleased-SgNBRelConf-Item-SgNBPDCPnotpresent,
28199                 ...
28200         },
28201         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelConf-ItemExtIEs} }     OPTIONAL,
28202         ...
28203 }
28204 */
28205
28206 struct E_RABs_ToBeReleased_SgNBRelConf_Item : asn::sequence<4, 0, true, 1>
28207 {
28208         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConf-Item";}
28209         using parent_t = asn::sequence<4, 0, true, 1>;
28210         struct e_RAB_ID_t : E_RAB_ID
28211         {
28212                 static constexpr const char* name() {return "e_RAB_ID_t";}
28213                 using parent_t = E_RAB_ID;
28214
28215         };
28216         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
28217         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
28218         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
28219         {
28220                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
28221                 using parent_t = EN_DC_ResourceConfiguration;
28222
28223         };
28224         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
28225         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
28226         struct resource_configuration_t : asn::choice<2, 0, true>
28227         {
28228                 static constexpr const char* name() {return "resource_configuration_t";}
28229                 using parent_t = asn::choice<2, 0, true>;
28230                 index_type get_index() const {return index;}
28231                 bool is_unknown() const {return index == 3;}
28232                 void set_unknown() { set_index(3);  }
28233                 ~resource_configuration_t() {clear();}
28234                 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent
28235                 {
28236                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
28237                         using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPpresent;
28238
28239                 };
28240                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent
28241                 {
28242                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
28243                         using parent_t = E_RABs_ToBeReleased_SgNBRelConf_Item_SgNBPDCPnotpresent;
28244
28245                 };
28246                 void clear()
28247                 {
28248                         switch(get_index())
28249                         {
28250                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
28251                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
28252                         }
28253                         index = 0;
28254                         base::clear();
28255                 }
28256                 template<typename V> bool decode(size_t idx, V& v)
28257                 {
28258                         clear();
28259                         switch(idx)
28260                         {
28261                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
28262                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
28263                         }
28264                         return false;
28265
28266                 }
28267                 template<typename V> bool encode(V& v) const
28268                 {
28269                         switch(get_index())
28270                         {
28271                         case 1: return v(var.as<sgNBPDCPpresent_t>());
28272                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
28273                         }
28274                         return false;
28275                 }
28276                 template<typename V> static inline void enumerate(V& v)
28277                 {
28278                         v.template operator()<sgNBPDCPpresent_t>(1);
28279                         v.template operator()<sgNBPDCPnotpresent_t>(2);
28280
28281                 }
28282                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
28283                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
28284                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
28285                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
28286                 private:
28287                 void set_index(index_type i) {index = i; base::set();}
28288                 union union_type
28289                 {
28290                         char dummy1[sizeof(sgNBPDCPpresent_t)];
28291                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
28292
28293                 };
28294                 asn::variant<sizeof(union_type)>        var;
28295                 index_type      index {0};
28296         };
28297         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
28298         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
28299         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>
28300         {
28301                 static constexpr const char* name() {return "iE_Extensions_t";}
28302                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelConf_ItemExtIEs>;
28303                 static constexpr bool optional = true;
28304
28305         };
28306         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28307         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28308         template<typename V> void decode(V& v)
28309         {
28310                 v(e_RAB_ID);
28311                 v(en_DC_ResourceConfiguration);
28312                 v(resource_configuration);
28313                 v(iE_Extensions);
28314
28315         };
28316         template<typename V> void encode(V& v) const
28317         {
28318                 v(e_RAB_ID);
28319                 v(en_DC_ResourceConfiguration);
28320                 v(resource_configuration);
28321                 v(iE_Extensions);
28322
28323         };
28324         void clear()
28325         {
28326                 e_RAB_ID.clear();
28327                 en_DC_ResourceConfiguration.clear();
28328                 resource_configuration.clear();
28329                 iE_Extensions.clear();
28330
28331         };
28332         private:
28333         e_RAB_ID_t      e_RAB_ID;
28334         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
28335         resource_configuration_t        resource_configuration;
28336         iE_Extensions_t iE_Extensions;
28337
28338 };
28339 /*
28340 E-RABs-ToBeReleased-SgNBRelConf-ItemIEs X2AP-PROTOCOL-IES ::= {
28341         { ID id-E-RABs-ToBeReleased-SgNBRelConf-Item            CRITICALITY ignore              TYPE E-RABs-ToBeReleased-SgNBRelConf-Item               PRESENCE mandatory},
28342         ...
28343 }
28344 */
28345
28346 struct E_RABs_ToBeReleased_SgNBRelConf_ItemIEs
28347 {
28348         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
28349         {
28350                 size_t get_index() const {return type;}
28351                 bool is_unknown() const { return type == 2; }
28352                 void clear() {type = 0;}
28353                 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(id_E_RABs_ToBeReleased_SgNBRelConf_Item); type=1;}
28354                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
28355                 template<typename V>  bool decode(V& v)
28356                 {
28357                         clear();
28358                         if(!v(ref_nested())) return false;
28359                         if(equal(id_E_RABs_ToBeReleased_SgNBRelConf_Item)) { type = 1; return true; }
28360                         else { type = 2; return true;}
28361                         return false;
28362
28363                 }
28364                 template<typename V> bool encode(V& v) const
28365                 {
28366                         return v(ref_nested());
28367
28368                 }
28369                 protected:
28370                 template<typename V>  bool decode(size_t index, V& v)
28371                 {
28372                         clear();
28373                         switch(index)
28374                         {
28375                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelConf_Item);} return false;
28376                         case 2: type = 2; return v(ref_nested());
28377                         ref_nested().clear();
28378                         }
28379                         return false;
28380
28381                 }
28382                 template<typename V> bool encode(size_t index, V& v) const
28383                 {
28384                         if(index != type) {return false;} return v(ref_nested());
28385
28386                 }
28387                 private:
28388                 size_t type {0};
28389
28390         };
28391         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
28392         {
28393                 size_t get_index() const {return type;}
28394                 bool is_unknown() const { return type == 2; }
28395                 void clear() {type = 0;}
28396                 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(ignore); type=1;}
28397                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
28398                 template<typename V>  bool decode(V& v)
28399                 {
28400                         clear();
28401                         if(!v(ref_nested())) return false;
28402                         if(equal(ignore)) { type = 1; return true; }
28403                         else { type = 2; return true;}
28404                         return false;
28405
28406                 }
28407                 template<typename V> bool encode(V& v) const
28408                 {
28409                         return v(ref_nested());
28410
28411                 }
28412                 protected:
28413                 template<typename V>  bool decode(size_t index, V& v)
28414                 {
28415                         clear();
28416                         switch(index)
28417                         {
28418                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
28419                         case 2: type = 2; return v(ref_nested());
28420                         ref_nested().clear();
28421                         }
28422                         return false;
28423
28424                 }
28425                 template<typename V> bool encode(size_t index, V& v) const
28426                 {
28427                         if(index != type) {return false;} return v(ref_nested());
28428
28429                 }
28430                 private:
28431                 size_t type {0};
28432
28433         };
28434         struct Value_t : asn::typefield<true>
28435         {
28436                 ~Value_t()      {clear();}
28437                 size_t get_index() const {return type;}
28438                 E_RABs_ToBeReleased_SgNBRelConf_Item& select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { return set<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
28439                 E_RABs_ToBeReleased_SgNBRelConf_Item const* get_id_E_RABs_ToBeReleased_SgNBRelConf_Item() const { return get<E_RABs_ToBeReleased_SgNBRelConf_Item>(1); }
28440                 bool is_unknown() const { return type == 2; }
28441                 void clear()
28442                 {
28443                         switch(type)
28444                         {
28445                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelConf_Item>(); break;
28446                         }
28447                         type = 0; ref_nested().clear();
28448                 }
28449                 template<typename V> static inline void enumerate(V& v)
28450                 {
28451                         v.template operator()<E_RABs_ToBeReleased_SgNBRelConf_Item>(1);
28452
28453                 }
28454                 protected:
28455                 template<typename V> bool decode(size_t index, V& v)
28456                 {
28457                         clear();
28458                         switch(index)
28459                         {
28460                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelConf_Item()); return true;
28461                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
28462                         }
28463                         return false;
28464
28465                 }
28466                 template<typename V> bool encode(size_t index, V& v) const
28467                 {
28468                         if(index != type) return false;
28469                         switch(type)
28470                         {
28471                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelConf_Item>()); return true;
28472                         }
28473                         return false;
28474
28475                 }
28476                 private:
28477                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
28478                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
28479                 union union_type
28480                 {
28481                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelConf_Item)];
28482
28483                 };
28484                 asn::variant<sizeof(union_type)> var;
28485                 size_t type {0};
28486
28487         };
28488         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
28489         {
28490                 size_t get_index() const {return type;}
28491                 bool is_unknown() const { return type == 2; }
28492                 void clear() {type = 0;}
28493                 void select_id_E_RABs_ToBeReleased_SgNBRelConf_Item() { set(mandatory); type=1;}
28494                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
28495                 template<typename V>  bool decode(V& v)
28496                 {
28497                         clear();
28498                         if(!v(ref_nested())) return false;
28499                         if(equal(mandatory)) { type = 1; return true; }
28500                         else { type = 2; return true;}
28501                         return false;
28502
28503                 }
28504                 template<typename V> bool encode(V& v) const
28505                 {
28506                         return v(ref_nested());
28507
28508                 }
28509                 protected:
28510                 template<typename V>  bool decode(size_t index, V& v)
28511                 {
28512                         clear();
28513                         switch(index)
28514                         {
28515                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
28516                         case 2: type = 2; return v(ref_nested());
28517                         ref_nested().clear();
28518                         }
28519                         return false;
28520
28521                 }
28522                 template<typename V> bool encode(size_t index, V& v) const
28523                 {
28524                         if(index != type) {return false;} return v(ref_nested());
28525
28526                 }
28527                 private:
28528                 size_t type {0};
28529
28530         };
28531
28532 };
28533 /*
28534 E-RABs-ToBeReleased-SgNBRelConfList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelConf-ItemIEs} }
28535 */
28536
28537 struct E_RABs_ToBeReleased_SgNBRelConfList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>
28538 {
28539         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelConfList_elm";}
28540         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelConf_ItemIEs>;
28541
28542 };
28543 struct E_RABs_ToBeReleased_SgNBRelConfList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>
28544 {
28545         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelConfList";}
28546         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelConfList_elm>;
28547         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
28548
28549 };
28550 /*
28551 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28552         ...
28553 }
28554 */
28555
28556 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs
28557 {
28558         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28559         {
28560                 size_t get_index() const {return type;}
28561                 bool is_unknown() const { return type == 1; }
28562                 void clear() {type = 0;}
28563                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28564                 template<typename V>  bool decode(V& v)
28565                 {
28566                         clear();
28567                         if(!v(ref_nested())) return false;
28568                         { type = 1; return true;}
28569                         return false;
28570
28571                 }
28572                 template<typename V> bool encode(V& v) const
28573                 {
28574                         return v(ref_nested());
28575
28576                 }
28577                 protected:
28578                 template<typename V>  bool decode(size_t index, V& v)
28579                 {
28580                         clear();
28581                         switch(index)
28582                         {
28583                         case 1: type = 1; return v(ref_nested());
28584                         ref_nested().clear();
28585                         }
28586                         return false;
28587
28588                 }
28589                 template<typename V> bool encode(size_t index, V& v) const
28590                 {
28591                         if(index != type) {return false;} return v(ref_nested());
28592
28593                 }
28594                 private:
28595                 size_t type {0};
28596
28597         };
28598         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28599         {
28600                 size_t get_index() const {return type;}
28601                 bool is_unknown() const { return type == 1; }
28602                 void clear() {type = 0;}
28603                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28604                 template<typename V>  bool decode(V& v)
28605                 {
28606                         clear();
28607                         if(!v(ref_nested())) return false;
28608                         { type = 1; return true;}
28609                         return false;
28610
28611                 }
28612                 template<typename V> bool encode(V& v) const
28613                 {
28614                         return v(ref_nested());
28615
28616                 }
28617                 protected:
28618                 template<typename V>  bool decode(size_t index, V& v)
28619                 {
28620                         clear();
28621                         switch(index)
28622                         {
28623                         case 1: type = 1; return v(ref_nested());
28624                         ref_nested().clear();
28625                         }
28626                         return false;
28627
28628                 }
28629                 template<typename V> bool encode(size_t index, V& v) const
28630                 {
28631                         if(index != type) {return false;} return v(ref_nested());
28632
28633                 }
28634                 private:
28635                 size_t type {0};
28636
28637         };
28638         struct Extension_t : asn::typefield<true>
28639         {
28640                 ~Extension_t()  {clear();}
28641                 size_t get_index() const {return type;}
28642                 bool is_unknown() const { return type == 1; }
28643                 void clear()
28644                 {
28645                         type = 0; ref_nested().clear();
28646                 }
28647                 template<typename V> static inline void enumerate(V& v)
28648                 {
28649
28650                 }
28651                 protected:
28652                 template<typename V> bool decode(size_t index, V& v)
28653                 {
28654                         clear();
28655                         switch(index)
28656                         {
28657                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28658                         }
28659                         return false;
28660
28661                 }
28662                 template<typename V> bool encode(size_t index, V& v) const
28663                 {
28664                         if(index != type) return false;
28665                         return false;
28666
28667                 }
28668                 private:
28669                 size_t type {0};
28670
28671         };
28672         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28673         {
28674                 size_t get_index() const {return type;}
28675                 bool is_unknown() const { return type == 1; }
28676                 void clear() {type = 0;}
28677                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28678                 template<typename V>  bool decode(V& v)
28679                 {
28680                         clear();
28681                         if(!v(ref_nested())) return false;
28682                         { type = 1; return true;}
28683                         return false;
28684
28685                 }
28686                 template<typename V> bool encode(V& v) const
28687                 {
28688                         return v(ref_nested());
28689
28690                 }
28691                 protected:
28692                 template<typename V>  bool decode(size_t index, V& v)
28693                 {
28694                         clear();
28695                         switch(index)
28696                         {
28697                         case 1: type = 1; return v(ref_nested());
28698                         ref_nested().clear();
28699                         }
28700                         return false;
28701
28702                 }
28703                 template<typename V> bool encode(size_t index, V& v) const
28704                 {
28705                         if(index != type) {return false;} return v(ref_nested());
28706
28707                 }
28708                 private:
28709                 size_t type {0};
28710
28711         };
28712
28713 };
28714 /*
28715 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent ::= SEQUENCE {
28716         uL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                       OPTIONAL,
28717         dL-GTPtunnelEndpoint                    GTPtunnelEndpoint                                                                                                                                                               OPTIONAL,
28718         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresentExtIEs} }      OPTIONAL,
28719         ...
28720 }
28721 */
28722
28723 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent : asn::sequence<3, 0, true, 3>
28724 {
28725         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent";}
28726         using parent_t = asn::sequence<3, 0, true, 3>;
28727         struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
28728         {
28729                 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
28730                 using parent_t = GTPtunnelEndpoint;
28731                 static constexpr bool optional = true;
28732
28733         };
28734         uL_GTPtunnelEndpoint_t& set_uL_GTPtunnelEndpoint() { uL_GTPtunnelEndpoint.setpresent(true); return uL_GTPtunnelEndpoint;}
28735         uL_GTPtunnelEndpoint_t const* get_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint.is_valid() ? &uL_GTPtunnelEndpoint : nullptr;}
28736         struct dL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
28737         {
28738                 static constexpr const char* name() {return "dL_GTPtunnelEndpoint_t";}
28739                 using parent_t = GTPtunnelEndpoint;
28740                 static constexpr bool optional = true;
28741
28742         };
28743         dL_GTPtunnelEndpoint_t& set_dL_GTPtunnelEndpoint() { dL_GTPtunnelEndpoint.setpresent(true); return dL_GTPtunnelEndpoint;}
28744         dL_GTPtunnelEndpoint_t const* get_dL_GTPtunnelEndpoint() const {return dL_GTPtunnelEndpoint.is_valid() ? &dL_GTPtunnelEndpoint : nullptr;}
28745         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>
28746         {
28747                 static constexpr const char* name() {return "iE_Extensions_t";}
28748                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresentExtIEs>;
28749                 static constexpr bool optional = true;
28750
28751         };
28752         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28753         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28754         template<typename V> void decode(V& v)
28755         {
28756                 v(uL_GTPtunnelEndpoint);
28757                 v(dL_GTPtunnelEndpoint);
28758                 v(iE_Extensions);
28759
28760         };
28761         template<typename V> void encode(V& v) const
28762         {
28763                 v(uL_GTPtunnelEndpoint);
28764                 v(dL_GTPtunnelEndpoint);
28765                 v(iE_Extensions);
28766
28767         };
28768         void clear()
28769         {
28770                 uL_GTPtunnelEndpoint.clear();
28771                 dL_GTPtunnelEndpoint.clear();
28772                 iE_Extensions.clear();
28773
28774         };
28775         private:
28776         uL_GTPtunnelEndpoint_t  uL_GTPtunnelEndpoint;
28777         dL_GTPtunnelEndpoint_t  dL_GTPtunnelEndpoint;
28778         iE_Extensions_t iE_Extensions;
28779
28780 };
28781 /*
28782 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28783         ...
28784 }
28785 */
28786
28787 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs
28788 {
28789         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28790         {
28791                 size_t get_index() const {return type;}
28792                 bool is_unknown() const { return type == 1; }
28793                 void clear() {type = 0;}
28794                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28795                 template<typename V>  bool decode(V& v)
28796                 {
28797                         clear();
28798                         if(!v(ref_nested())) return false;
28799                         { type = 1; return true;}
28800                         return false;
28801
28802                 }
28803                 template<typename V> bool encode(V& v) const
28804                 {
28805                         return v(ref_nested());
28806
28807                 }
28808                 protected:
28809                 template<typename V>  bool decode(size_t index, V& v)
28810                 {
28811                         clear();
28812                         switch(index)
28813                         {
28814                         case 1: type = 1; return v(ref_nested());
28815                         ref_nested().clear();
28816                         }
28817                         return false;
28818
28819                 }
28820                 template<typename V> bool encode(size_t index, V& v) const
28821                 {
28822                         if(index != type) {return false;} return v(ref_nested());
28823
28824                 }
28825                 private:
28826                 size_t type {0};
28827
28828         };
28829         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28830         {
28831                 size_t get_index() const {return type;}
28832                 bool is_unknown() const { return type == 1; }
28833                 void clear() {type = 0;}
28834                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28835                 template<typename V>  bool decode(V& v)
28836                 {
28837                         clear();
28838                         if(!v(ref_nested())) return false;
28839                         { type = 1; return true;}
28840                         return false;
28841
28842                 }
28843                 template<typename V> bool encode(V& v) const
28844                 {
28845                         return v(ref_nested());
28846
28847                 }
28848                 protected:
28849                 template<typename V>  bool decode(size_t index, V& v)
28850                 {
28851                         clear();
28852                         switch(index)
28853                         {
28854                         case 1: type = 1; return v(ref_nested());
28855                         ref_nested().clear();
28856                         }
28857                         return false;
28858
28859                 }
28860                 template<typename V> bool encode(size_t index, V& v) const
28861                 {
28862                         if(index != type) {return false;} return v(ref_nested());
28863
28864                 }
28865                 private:
28866                 size_t type {0};
28867
28868         };
28869         struct Extension_t : asn::typefield<true>
28870         {
28871                 ~Extension_t()  {clear();}
28872                 size_t get_index() const {return type;}
28873                 bool is_unknown() const { return type == 1; }
28874                 void clear()
28875                 {
28876                         type = 0; ref_nested().clear();
28877                 }
28878                 template<typename V> static inline void enumerate(V& v)
28879                 {
28880
28881                 }
28882                 protected:
28883                 template<typename V> bool decode(size_t index, V& v)
28884                 {
28885                         clear();
28886                         switch(index)
28887                         {
28888                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28889                         }
28890                         return false;
28891
28892                 }
28893                 template<typename V> bool encode(size_t index, V& v) const
28894                 {
28895                         if(index != type) return false;
28896                         return false;
28897
28898                 }
28899                 private:
28900                 size_t type {0};
28901
28902         };
28903         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28904         {
28905                 size_t get_index() const {return type;}
28906                 bool is_unknown() const { return type == 1; }
28907                 void clear() {type = 0;}
28908                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28909                 template<typename V>  bool decode(V& v)
28910                 {
28911                         clear();
28912                         if(!v(ref_nested())) return false;
28913                         { type = 1; return true;}
28914                         return false;
28915
28916                 }
28917                 template<typename V> bool encode(V& v) const
28918                 {
28919                         return v(ref_nested());
28920
28921                 }
28922                 protected:
28923                 template<typename V>  bool decode(size_t index, V& v)
28924                 {
28925                         clear();
28926                         switch(index)
28927                         {
28928                         case 1: type = 1; return v(ref_nested());
28929                         ref_nested().clear();
28930                         }
28931                         return false;
28932
28933                 }
28934                 template<typename V> bool encode(size_t index, V& v) const
28935                 {
28936                         if(index != type) {return false;} return v(ref_nested());
28937
28938                 }
28939                 private:
28940                 size_t type {0};
28941
28942         };
28943
28944 };
28945 /*
28946 E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent ::= SEQUENCE {
28947         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresentExtIEs} }   OPTIONAL,
28948         ...
28949 }
28950 */
28951
28952 struct E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent : asn::sequence<1, 0, true, 1>
28953 {
28954         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent";}
28955         using parent_t = asn::sequence<1, 0, true, 1>;
28956         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>
28957         {
28958                 static constexpr const char* name() {return "iE_Extensions_t";}
28959                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresentExtIEs>;
28960                 static constexpr bool optional = true;
28961
28962         };
28963         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28964         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28965         template<typename V> void decode(V& v)
28966         {
28967                 v(iE_Extensions);
28968
28969         };
28970         template<typename V> void encode(V& v) const
28971         {
28972                 v(iE_Extensions);
28973
28974         };
28975         void clear()
28976         {
28977                 iE_Extensions.clear();
28978
28979         };
28980         private:
28981         iE_Extensions_t iE_Extensions;
28982
28983 };
28984 /*
28985 E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28986         ...
28987 }
28988 */
28989
28990 struct E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs
28991 {
28992         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28993         {
28994                 size_t get_index() const {return type;}
28995                 bool is_unknown() const { return type == 1; }
28996                 void clear() {type = 0;}
28997                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28998                 template<typename V>  bool decode(V& v)
28999                 {
29000                         clear();
29001                         if(!v(ref_nested())) return false;
29002                         { type = 1; return true;}
29003                         return false;
29004
29005                 }
29006                 template<typename V> bool encode(V& v) const
29007                 {
29008                         return v(ref_nested());
29009
29010                 }
29011                 protected:
29012                 template<typename V>  bool decode(size_t index, V& v)
29013                 {
29014                         clear();
29015                         switch(index)
29016                         {
29017                         case 1: type = 1; return v(ref_nested());
29018                         ref_nested().clear();
29019                         }
29020                         return false;
29021
29022                 }
29023                 template<typename V> bool encode(size_t index, V& v) const
29024                 {
29025                         if(index != type) {return false;} return v(ref_nested());
29026
29027                 }
29028                 private:
29029                 size_t type {0};
29030
29031         };
29032         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29033         {
29034                 size_t get_index() const {return type;}
29035                 bool is_unknown() const { return type == 1; }
29036                 void clear() {type = 0;}
29037                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29038                 template<typename V>  bool decode(V& v)
29039                 {
29040                         clear();
29041                         if(!v(ref_nested())) return false;
29042                         { type = 1; return true;}
29043                         return false;
29044
29045                 }
29046                 template<typename V> bool encode(V& v) const
29047                 {
29048                         return v(ref_nested());
29049
29050                 }
29051                 protected:
29052                 template<typename V>  bool decode(size_t index, V& v)
29053                 {
29054                         clear();
29055                         switch(index)
29056                         {
29057                         case 1: type = 1; return v(ref_nested());
29058                         ref_nested().clear();
29059                         }
29060                         return false;
29061
29062                 }
29063                 template<typename V> bool encode(size_t index, V& v) const
29064                 {
29065                         if(index != type) {return false;} return v(ref_nested());
29066
29067                 }
29068                 private:
29069                 size_t type {0};
29070
29071         };
29072         struct Extension_t : asn::typefield<true>
29073         {
29074                 ~Extension_t()  {clear();}
29075                 size_t get_index() const {return type;}
29076                 bool is_unknown() const { return type == 1; }
29077                 void clear()
29078                 {
29079                         type = 0; ref_nested().clear();
29080                 }
29081                 template<typename V> static inline void enumerate(V& v)
29082                 {
29083
29084                 }
29085                 protected:
29086                 template<typename V> bool decode(size_t index, V& v)
29087                 {
29088                         clear();
29089                         switch(index)
29090                         {
29091                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
29092                         }
29093                         return false;
29094
29095                 }
29096                 template<typename V> bool encode(size_t index, V& v) const
29097                 {
29098                         if(index != type) return false;
29099                         return false;
29100
29101                 }
29102                 private:
29103                 size_t type {0};
29104
29105         };
29106         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29107         {
29108                 size_t get_index() const {return type;}
29109                 bool is_unknown() const { return type == 1; }
29110                 void clear() {type = 0;}
29111                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29112                 template<typename V>  bool decode(V& v)
29113                 {
29114                         clear();
29115                         if(!v(ref_nested())) return false;
29116                         { type = 1; return true;}
29117                         return false;
29118
29119                 }
29120                 template<typename V> bool encode(V& v) const
29121                 {
29122                         return v(ref_nested());
29123
29124                 }
29125                 protected:
29126                 template<typename V>  bool decode(size_t index, V& v)
29127                 {
29128                         clear();
29129                         switch(index)
29130                         {
29131                         case 1: type = 1; return v(ref_nested());
29132                         ref_nested().clear();
29133                         }
29134                         return false;
29135
29136                 }
29137                 template<typename V> bool encode(size_t index, V& v) const
29138                 {
29139                         if(index != type) {return false;} return v(ref_nested());
29140
29141                 }
29142                 private:
29143                 size_t type {0};
29144
29145         };
29146
29147 };
29148 /*
29149 E-RABs-ToBeReleased-SgNBRelReq-Item ::= SEQUENCE {
29150         e-RAB-ID                                                        E-RAB-ID,
29151         en-DC-ResourceConfiguration                     EN-DC-ResourceConfiguration,
29152         resource-configuration                          CHOICE {
29153                 sgNBPDCPpresent                                         E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPpresent,
29154                 sgNBPDCPnotpresent                                      E-RABs-ToBeReleased-SgNBRelReq-Item-SgNBPDCPnotpresent,
29155                 ...
29156         },
29157         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReq-ItemExtIEs} }      OPTIONAL,
29158         ...
29159 }
29160 */
29161
29162 struct E_RABs_ToBeReleased_SgNBRelReq_Item : asn::sequence<4, 0, true, 1>
29163 {
29164         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReq-Item";}
29165         using parent_t = asn::sequence<4, 0, true, 1>;
29166         struct e_RAB_ID_t : E_RAB_ID
29167         {
29168                 static constexpr const char* name() {return "e_RAB_ID_t";}
29169                 using parent_t = E_RAB_ID;
29170
29171         };
29172         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
29173         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
29174         struct en_DC_ResourceConfiguration_t : EN_DC_ResourceConfiguration
29175         {
29176                 static constexpr const char* name() {return "en_DC_ResourceConfiguration_t";}
29177                 using parent_t = EN_DC_ResourceConfiguration;
29178
29179         };
29180         en_DC_ResourceConfiguration_t& ref_en_DC_ResourceConfiguration() {return en_DC_ResourceConfiguration;}
29181         en_DC_ResourceConfiguration_t const& ref_en_DC_ResourceConfiguration() const {return en_DC_ResourceConfiguration;}
29182         struct resource_configuration_t : asn::choice<2, 0, true>
29183         {
29184                 static constexpr const char* name() {return "resource_configuration_t";}
29185                 using parent_t = asn::choice<2, 0, true>;
29186                 index_type get_index() const {return index;}
29187                 bool is_unknown() const {return index == 3;}
29188                 void set_unknown() { set_index(3);  }
29189                 ~resource_configuration_t() {clear();}
29190                 struct sgNBPDCPpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent
29191                 {
29192                         static constexpr const char* name() {return "sgNBPDCPpresent_t";}
29193                         using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPpresent;
29194
29195                 };
29196                 struct sgNBPDCPnotpresent_t : E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent
29197                 {
29198                         static constexpr const char* name() {return "sgNBPDCPnotpresent_t";}
29199                         using parent_t = E_RABs_ToBeReleased_SgNBRelReq_Item_SgNBPDCPnotpresent;
29200
29201                 };
29202                 void clear()
29203                 {
29204                         switch(get_index())
29205                         {
29206                         case 1: var.destroy<sgNBPDCPpresent_t>(); break;
29207                         case 2: var.destroy<sgNBPDCPnotpresent_t>(); break;
29208                         }
29209                         index = 0;
29210                         base::clear();
29211                 }
29212                 template<typename V> bool decode(size_t idx, V& v)
29213                 {
29214                         clear();
29215                         switch(idx)
29216                         {
29217                         case 1: set_index(1); return v(var.build<sgNBPDCPpresent_t>());
29218                         case 2: set_index(2); return v(var.build<sgNBPDCPnotpresent_t>());
29219                         }
29220                         return false;
29221
29222                 }
29223                 template<typename V> bool encode(V& v) const
29224                 {
29225                         switch(get_index())
29226                         {
29227                         case 1: return v(var.as<sgNBPDCPpresent_t>());
29228                         case 2: return v(var.as<sgNBPDCPnotpresent_t>());
29229                         }
29230                         return false;
29231                 }
29232                 template<typename V> static inline void enumerate(V& v)
29233                 {
29234                         v.template operator()<sgNBPDCPpresent_t>(1);
29235                         v.template operator()<sgNBPDCPnotpresent_t>(2);
29236
29237                 }
29238                 sgNBPDCPpresent_t& select_sgNBPDCPpresent() { if(get_index() != 1) { clear(); set_index(1); return var.build<sgNBPDCPpresent_t>();} return var.as<sgNBPDCPpresent_t>();}
29239                 sgNBPDCPpresent_t const* get_sgNBPDCPpresent() const { if(get_index() == 1) { return &var.as<sgNBPDCPpresent_t>();} return nullptr; }
29240                 sgNBPDCPnotpresent_t& select_sgNBPDCPnotpresent() { if(get_index() != 2) { clear(); set_index(2); return var.build<sgNBPDCPnotpresent_t>();} return var.as<sgNBPDCPnotpresent_t>();}
29241                 sgNBPDCPnotpresent_t const* get_sgNBPDCPnotpresent() const { if(get_index() == 2) { return &var.as<sgNBPDCPnotpresent_t>();} return nullptr; }
29242                 private:
29243                 void set_index(index_type i) {index = i; base::set();}
29244                 union union_type
29245                 {
29246                         char dummy1[sizeof(sgNBPDCPpresent_t)];
29247                         char dummy2[sizeof(sgNBPDCPnotpresent_t)];
29248
29249                 };
29250                 asn::variant<sizeof(union_type)>        var;
29251                 index_type      index {0};
29252         };
29253         resource_configuration_t& ref_resource_configuration() {return resource_configuration;}
29254         resource_configuration_t const& ref_resource_configuration() const {return resource_configuration;}
29255         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>
29256         {
29257                 static constexpr const char* name() {return "iE_Extensions_t";}
29258                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReq_ItemExtIEs>;
29259                 static constexpr bool optional = true;
29260
29261         };
29262         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29263         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29264         template<typename V> void decode(V& v)
29265         {
29266                 v(e_RAB_ID);
29267                 v(en_DC_ResourceConfiguration);
29268                 v(resource_configuration);
29269                 v(iE_Extensions);
29270
29271         };
29272         template<typename V> void encode(V& v) const
29273         {
29274                 v(e_RAB_ID);
29275                 v(en_DC_ResourceConfiguration);
29276                 v(resource_configuration);
29277                 v(iE_Extensions);
29278
29279         };
29280         void clear()
29281         {
29282                 e_RAB_ID.clear();
29283                 en_DC_ResourceConfiguration.clear();
29284                 resource_configuration.clear();
29285                 iE_Extensions.clear();
29286
29287         };
29288         private:
29289         e_RAB_ID_t      e_RAB_ID;
29290         en_DC_ResourceConfiguration_t   en_DC_ResourceConfiguration;
29291         resource_configuration_t        resource_configuration;
29292         iE_Extensions_t iE_Extensions;
29293
29294 };
29295 /*
29296 E-RABs-ToBeReleased-SgNBRelReq-ItemIEs X2AP-PROTOCOL-IES ::= {
29297         { ID id-E-RABs-ToBeReleased-SgNBRelReq-Item             CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBRelReq-Item                PRESENCE mandatory},
29298         ...
29299 }
29300 */
29301
29302 struct E_RABs_ToBeReleased_SgNBRelReq_ItemIEs
29303 {
29304         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
29305         {
29306                 size_t get_index() const {return type;}
29307                 bool is_unknown() const { return type == 2; }
29308                 void clear() {type = 0;}
29309                 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReq_Item); type=1;}
29310                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
29311                 template<typename V>  bool decode(V& v)
29312                 {
29313                         clear();
29314                         if(!v(ref_nested())) return false;
29315                         if(equal(id_E_RABs_ToBeReleased_SgNBRelReq_Item)) { type = 1; return true; }
29316                         else { type = 2; return true;}
29317                         return false;
29318
29319                 }
29320                 template<typename V> bool encode(V& v) const
29321                 {
29322                         return v(ref_nested());
29323
29324                 }
29325                 protected:
29326                 template<typename V>  bool decode(size_t index, V& v)
29327                 {
29328                         clear();
29329                         switch(index)
29330                         {
29331                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReq_Item);} return false;
29332                         case 2: type = 2; return v(ref_nested());
29333                         ref_nested().clear();
29334                         }
29335                         return false;
29336
29337                 }
29338                 template<typename V> bool encode(size_t index, V& v) const
29339                 {
29340                         if(index != type) {return false;} return v(ref_nested());
29341
29342                 }
29343                 private:
29344                 size_t type {0};
29345
29346         };
29347         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
29348         {
29349                 size_t get_index() const {return type;}
29350                 bool is_unknown() const { return type == 2; }
29351                 void clear() {type = 0;}
29352                 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(ignore); type=1;}
29353                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
29354                 template<typename V>  bool decode(V& v)
29355                 {
29356                         clear();
29357                         if(!v(ref_nested())) return false;
29358                         if(equal(ignore)) { type = 1; return true; }
29359                         else { type = 2; return true;}
29360                         return false;
29361
29362                 }
29363                 template<typename V> bool encode(V& v) const
29364                 {
29365                         return v(ref_nested());
29366
29367                 }
29368                 protected:
29369                 template<typename V>  bool decode(size_t index, V& v)
29370                 {
29371                         clear();
29372                         switch(index)
29373                         {
29374                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29375                         case 2: type = 2; return v(ref_nested());
29376                         ref_nested().clear();
29377                         }
29378                         return false;
29379
29380                 }
29381                 template<typename V> bool encode(size_t index, V& v) const
29382                 {
29383                         if(index != type) {return false;} return v(ref_nested());
29384
29385                 }
29386                 private:
29387                 size_t type {0};
29388
29389         };
29390         struct Value_t : asn::typefield<true>
29391         {
29392                 ~Value_t()      {clear();}
29393                 size_t get_index() const {return type;}
29394                 E_RABs_ToBeReleased_SgNBRelReq_Item& select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { return set<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
29395                 E_RABs_ToBeReleased_SgNBRelReq_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReq_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReq_Item>(1); }
29396                 bool is_unknown() const { return type == 2; }
29397                 void clear()
29398                 {
29399                         switch(type)
29400                         {
29401                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReq_Item>(); break;
29402                         }
29403                         type = 0; ref_nested().clear();
29404                 }
29405                 template<typename V> static inline void enumerate(V& v)
29406                 {
29407                         v.template operator()<E_RABs_ToBeReleased_SgNBRelReq_Item>(1);
29408
29409                 }
29410                 protected:
29411                 template<typename V> bool decode(size_t index, V& v)
29412                 {
29413                         clear();
29414                         switch(index)
29415                         {
29416                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReq_Item()); return true;
29417                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29418                         }
29419                         return false;
29420
29421                 }
29422                 template<typename V> bool encode(size_t index, V& v) const
29423                 {
29424                         if(index != type) return false;
29425                         switch(type)
29426                         {
29427                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelReq_Item>()); return true;
29428                         }
29429                         return false;
29430
29431                 }
29432                 private:
29433                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29434                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29435                 union union_type
29436                 {
29437                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelReq_Item)];
29438
29439                 };
29440                 asn::variant<sizeof(union_type)> var;
29441                 size_t type {0};
29442
29443         };
29444         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
29445         {
29446                 size_t get_index() const {return type;}
29447                 bool is_unknown() const { return type == 2; }
29448                 void clear() {type = 0;}
29449                 void select_id_E_RABs_ToBeReleased_SgNBRelReq_Item() { set(mandatory); type=1;}
29450                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
29451                 template<typename V>  bool decode(V& v)
29452                 {
29453                         clear();
29454                         if(!v(ref_nested())) return false;
29455                         if(equal(mandatory)) { type = 1; return true; }
29456                         else { type = 2; return true;}
29457                         return false;
29458
29459                 }
29460                 template<typename V> bool encode(V& v) const
29461                 {
29462                         return v(ref_nested());
29463
29464                 }
29465                 protected:
29466                 template<typename V>  bool decode(size_t index, V& v)
29467                 {
29468                         clear();
29469                         switch(index)
29470                         {
29471                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
29472                         case 2: type = 2; return v(ref_nested());
29473                         ref_nested().clear();
29474                         }
29475                         return false;
29476
29477                 }
29478                 template<typename V> bool encode(size_t index, V& v) const
29479                 {
29480                         if(index != type) {return false;} return v(ref_nested());
29481
29482                 }
29483                 private:
29484                 size_t type {0};
29485
29486         };
29487
29488 };
29489 /*
29490 E-RABs-ToBeReleased-SgNBRelReqList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReq-ItemIEs} }
29491 */
29492
29493 struct E_RABs_ToBeReleased_SgNBRelReqList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>
29494 {
29495         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqList_elm";}
29496         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReq_ItemIEs>;
29497
29498 };
29499 struct E_RABs_ToBeReleased_SgNBRelReqList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>
29500 {
29501         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqList";}
29502         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqList_elm>;
29503         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
29504
29505 };
29506 /*
29507 E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29508         ...
29509 }
29510 */
29511
29512 struct E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs
29513 {
29514         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29515         {
29516                 size_t get_index() const {return type;}
29517                 bool is_unknown() const { return type == 1; }
29518                 void clear() {type = 0;}
29519                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29520                 template<typename V>  bool decode(V& v)
29521                 {
29522                         clear();
29523                         if(!v(ref_nested())) return false;
29524                         { type = 1; return true;}
29525                         return false;
29526
29527                 }
29528                 template<typename V> bool encode(V& v) const
29529                 {
29530                         return v(ref_nested());
29531
29532                 }
29533                 protected:
29534                 template<typename V>  bool decode(size_t index, V& v)
29535                 {
29536                         clear();
29537                         switch(index)
29538                         {
29539                         case 1: type = 1; return v(ref_nested());
29540                         ref_nested().clear();
29541                         }
29542                         return false;
29543
29544                 }
29545                 template<typename V> bool encode(size_t index, V& v) const
29546                 {
29547                         if(index != type) {return false;} return v(ref_nested());
29548
29549                 }
29550                 private:
29551                 size_t type {0};
29552
29553         };
29554         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29555         {
29556                 size_t get_index() const {return type;}
29557                 bool is_unknown() const { return type == 1; }
29558                 void clear() {type = 0;}
29559                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29560                 template<typename V>  bool decode(V& v)
29561                 {
29562                         clear();
29563                         if(!v(ref_nested())) return false;
29564                         { type = 1; return true;}
29565                         return false;
29566
29567                 }
29568                 template<typename V> bool encode(V& v) const
29569                 {
29570                         return v(ref_nested());
29571
29572                 }
29573                 protected:
29574                 template<typename V>  bool decode(size_t index, V& v)
29575                 {
29576                         clear();
29577                         switch(index)
29578                         {
29579                         case 1: type = 1; return v(ref_nested());
29580                         ref_nested().clear();
29581                         }
29582                         return false;
29583
29584                 }
29585                 template<typename V> bool encode(size_t index, V& v) const
29586                 {
29587                         if(index != type) {return false;} return v(ref_nested());
29588
29589                 }
29590                 private:
29591                 size_t type {0};
29592
29593         };
29594         struct Extension_t : asn::typefield<true>
29595         {
29596                 ~Extension_t()  {clear();}
29597                 size_t get_index() const {return type;}
29598                 bool is_unknown() const { return type == 1; }
29599                 void clear()
29600                 {
29601                         type = 0; ref_nested().clear();
29602                 }
29603                 template<typename V> static inline void enumerate(V& v)
29604                 {
29605
29606                 }
29607                 protected:
29608                 template<typename V> bool decode(size_t index, V& v)
29609                 {
29610                         clear();
29611                         switch(index)
29612                         {
29613                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
29614                         }
29615                         return false;
29616
29617                 }
29618                 template<typename V> bool encode(size_t index, V& v) const
29619                 {
29620                         if(index != type) return false;
29621                         return false;
29622
29623                 }
29624                 private:
29625                 size_t type {0};
29626
29627         };
29628         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29629         {
29630                 size_t get_index() const {return type;}
29631                 bool is_unknown() const { return type == 1; }
29632                 void clear() {type = 0;}
29633                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29634                 template<typename V>  bool decode(V& v)
29635                 {
29636                         clear();
29637                         if(!v(ref_nested())) return false;
29638                         { type = 1; return true;}
29639                         return false;
29640
29641                 }
29642                 template<typename V> bool encode(V& v) const
29643                 {
29644                         return v(ref_nested());
29645
29646                 }
29647                 protected:
29648                 template<typename V>  bool decode(size_t index, V& v)
29649                 {
29650                         clear();
29651                         switch(index)
29652                         {
29653                         case 1: type = 1; return v(ref_nested());
29654                         ref_nested().clear();
29655                         }
29656                         return false;
29657
29658                 }
29659                 template<typename V> bool encode(size_t index, V& v) const
29660                 {
29661                         if(index != type) {return false;} return v(ref_nested());
29662
29663                 }
29664                 private:
29665                 size_t type {0};
29666
29667         };
29668
29669 };
29670 /*
29671 E-RABs-ToBeReleased-SgNBRelReqd-Item ::= SEQUENCE {
29672         e-RAB-ID                                                        E-RAB-ID,
29673         rlc-Mode-transferred                    RLCMode,
29674         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeReleased-SgNBRelReqd-ItemExtIEs} }     OPTIONAL,
29675         ...
29676 }
29677 */
29678
29679 struct E_RABs_ToBeReleased_SgNBRelReqd_Item : asn::sequence<3, 0, true, 1>
29680 {
29681         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqd-Item";}
29682         using parent_t = asn::sequence<3, 0, true, 1>;
29683         struct e_RAB_ID_t : E_RAB_ID
29684         {
29685                 static constexpr const char* name() {return "e_RAB_ID_t";}
29686                 using parent_t = E_RAB_ID;
29687
29688         };
29689         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
29690         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
29691         struct rlc_Mode_transferred_t : RLCMode
29692         {
29693                 static constexpr const char* name() {return "rlc_Mode_transferred_t";}
29694                 using parent_t = RLCMode;
29695
29696         };
29697         rlc_Mode_transferred_t& ref_rlc_Mode_transferred() {return rlc_Mode_transferred;}
29698         rlc_Mode_transferred_t const& ref_rlc_Mode_transferred() const {return rlc_Mode_transferred;}
29699         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>
29700         {
29701                 static constexpr const char* name() {return "iE_Extensions_t";}
29702                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeReleased_SgNBRelReqd_ItemExtIEs>;
29703                 static constexpr bool optional = true;
29704
29705         };
29706         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29707         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29708         template<typename V> void decode(V& v)
29709         {
29710                 v(e_RAB_ID);
29711                 v(rlc_Mode_transferred);
29712                 v(iE_Extensions);
29713
29714         };
29715         template<typename V> void encode(V& v) const
29716         {
29717                 v(e_RAB_ID);
29718                 v(rlc_Mode_transferred);
29719                 v(iE_Extensions);
29720
29721         };
29722         void clear()
29723         {
29724                 e_RAB_ID.clear();
29725                 rlc_Mode_transferred.clear();
29726                 iE_Extensions.clear();
29727
29728         };
29729         private:
29730         e_RAB_ID_t      e_RAB_ID;
29731         rlc_Mode_transferred_t  rlc_Mode_transferred;
29732         iE_Extensions_t iE_Extensions;
29733
29734 };
29735 /*
29736 E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs X2AP-PROTOCOL-IES ::= {
29737         { ID id-E-RABs-ToBeReleased-SgNBRelReqd-Item            CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBRelReqd-Item               PRESENCE mandatory},
29738         ...
29739 }
29740 */
29741
29742 struct E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs
29743 {
29744         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
29745         {
29746                 size_t get_index() const {return type;}
29747                 bool is_unknown() const { return type == 2; }
29748                 void clear() {type = 0;}
29749                 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(id_E_RABs_ToBeReleased_SgNBRelReqd_Item); type=1;}
29750                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
29751                 template<typename V>  bool decode(V& v)
29752                 {
29753                         clear();
29754                         if(!v(ref_nested())) return false;
29755                         if(equal(id_E_RABs_ToBeReleased_SgNBRelReqd_Item)) { type = 1; return true; }
29756                         else { type = 2; return true;}
29757                         return false;
29758
29759                 }
29760                 template<typename V> bool encode(V& v) const
29761                 {
29762                         return v(ref_nested());
29763
29764                 }
29765                 protected:
29766                 template<typename V>  bool decode(size_t index, V& v)
29767                 {
29768                         clear();
29769                         switch(index)
29770                         {
29771                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqd_Item);} return false;
29772                         case 2: type = 2; return v(ref_nested());
29773                         ref_nested().clear();
29774                         }
29775                         return false;
29776
29777                 }
29778                 template<typename V> bool encode(size_t index, V& v) const
29779                 {
29780                         if(index != type) {return false;} return v(ref_nested());
29781
29782                 }
29783                 private:
29784                 size_t type {0};
29785
29786         };
29787         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
29788         {
29789                 size_t get_index() const {return type;}
29790                 bool is_unknown() const { return type == 2; }
29791                 void clear() {type = 0;}
29792                 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(ignore); type=1;}
29793                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
29794                 template<typename V>  bool decode(V& v)
29795                 {
29796                         clear();
29797                         if(!v(ref_nested())) return false;
29798                         if(equal(ignore)) { type = 1; return true; }
29799                         else { type = 2; return true;}
29800                         return false;
29801
29802                 }
29803                 template<typename V> bool encode(V& v) const
29804                 {
29805                         return v(ref_nested());
29806
29807                 }
29808                 protected:
29809                 template<typename V>  bool decode(size_t index, V& v)
29810                 {
29811                         clear();
29812                         switch(index)
29813                         {
29814                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29815                         case 2: type = 2; return v(ref_nested());
29816                         ref_nested().clear();
29817                         }
29818                         return false;
29819
29820                 }
29821                 template<typename V> bool encode(size_t index, V& v) const
29822                 {
29823                         if(index != type) {return false;} return v(ref_nested());
29824
29825                 }
29826                 private:
29827                 size_t type {0};
29828
29829         };
29830         struct Value_t : asn::typefield<true>
29831         {
29832                 ~Value_t()      {clear();}
29833                 size_t get_index() const {return type;}
29834                 E_RABs_ToBeReleased_SgNBRelReqd_Item& select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { return set<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
29835                 E_RABs_ToBeReleased_SgNBRelReqd_Item const* get_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() const { return get<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1); }
29836                 bool is_unknown() const { return type == 2; }
29837                 void clear()
29838                 {
29839                         switch(type)
29840                         {
29841                         case 1: var.destroy<E_RABs_ToBeReleased_SgNBRelReqd_Item>(); break;
29842                         }
29843                         type = 0; ref_nested().clear();
29844                 }
29845                 template<typename V> static inline void enumerate(V& v)
29846                 {
29847                         v.template operator()<E_RABs_ToBeReleased_SgNBRelReqd_Item>(1);
29848
29849                 }
29850                 protected:
29851                 template<typename V> bool decode(size_t index, V& v)
29852                 {
29853                         clear();
29854                         switch(index)
29855                         {
29856                         case 1: v(select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item()); return true;
29857                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29858                         }
29859                         return false;
29860
29861                 }
29862                 template<typename V> bool encode(size_t index, V& v) const
29863                 {
29864                         if(index != type) return false;
29865                         switch(type)
29866                         {
29867                         case 1: v(var.as<E_RABs_ToBeReleased_SgNBRelReqd_Item>()); return true;
29868                         }
29869                         return false;
29870
29871                 }
29872                 private:
29873                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29874                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29875                 union union_type
29876                 {
29877                         char dummy1[sizeof(E_RABs_ToBeReleased_SgNBRelReqd_Item)];
29878
29879                 };
29880                 asn::variant<sizeof(union_type)> var;
29881                 size_t type {0};
29882
29883         };
29884         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
29885         {
29886                 size_t get_index() const {return type;}
29887                 bool is_unknown() const { return type == 2; }
29888                 void clear() {type = 0;}
29889                 void select_id_E_RABs_ToBeReleased_SgNBRelReqd_Item() { set(mandatory); type=1;}
29890                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
29891                 template<typename V>  bool decode(V& v)
29892                 {
29893                         clear();
29894                         if(!v(ref_nested())) return false;
29895                         if(equal(mandatory)) { type = 1; return true; }
29896                         else { type = 2; return true;}
29897                         return false;
29898
29899                 }
29900                 template<typename V> bool encode(V& v) const
29901                 {
29902                         return v(ref_nested());
29903
29904                 }
29905                 protected:
29906                 template<typename V>  bool decode(size_t index, V& v)
29907                 {
29908                         clear();
29909                         switch(index)
29910                         {
29911                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
29912                         case 2: type = 2; return v(ref_nested());
29913                         ref_nested().clear();
29914                         }
29915                         return false;
29916
29917                 }
29918                 template<typename V> bool encode(size_t index, V& v) const
29919                 {
29920                         if(index != type) {return false;} return v(ref_nested());
29921
29922                 }
29923                 private:
29924                 size_t type {0};
29925
29926         };
29927
29928 };
29929 /*
29930 E-RABs-ToBeReleased-SgNBRelReqdList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeReleased-SgNBRelReqd-ItemIEs} }
29931 */
29932
29933 struct E_RABs_ToBeReleased_SgNBRelReqdList_elm : ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>
29934 {
29935         static constexpr const char* name() {return "E_RABs_ToBeReleased_SgNBRelReqdList_elm";}
29936         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeReleased_SgNBRelReqd_ItemIEs>;
29937
29938 };
29939 struct E_RABs_ToBeReleased_SgNBRelReqdList : asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>
29940 {
29941         static constexpr const char* name() {return "E-RABs-ToBeReleased-SgNBRelReqdList";}
29942         using parent_t = asn::sequenceof<E_RABs_ToBeReleased_SgNBRelReqdList_elm>;
29943         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
29944
29945 };
29946 /*
29947 E-RABs-ToBeSetup-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29948         { ID id-BearerType              CRITICALITY reject      EXTENSION BearerType            PRESENCE optional},
29949         ...
29950 }
29951 */
29952
29953 struct E_RABs_ToBeSetup_ItemExtIEs
29954 {
29955         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29956         {
29957                 size_t get_index() const {return type;}
29958                 bool is_unknown() const { return type == 2; }
29959                 void clear() {type = 0;}
29960                 void select_id_BearerType() { set(id_BearerType); type=1;}
29961                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29962                 template<typename V>  bool decode(V& v)
29963                 {
29964                         clear();
29965                         if(!v(ref_nested())) return false;
29966                         if(equal(id_BearerType)) { type = 1; return true; }
29967                         else { type = 2; return true;}
29968                         return false;
29969
29970                 }
29971                 template<typename V> bool encode(V& v) const
29972                 {
29973                         return v(ref_nested());
29974
29975                 }
29976                 protected:
29977                 template<typename V>  bool decode(size_t index, V& v)
29978                 {
29979                         clear();
29980                         switch(index)
29981                         {
29982                         case 1: type = 1; if(v(ref_nested())) { return equal(id_BearerType);} return false;
29983                         case 2: type = 2; return v(ref_nested());
29984                         ref_nested().clear();
29985                         }
29986                         return false;
29987
29988                 }
29989                 template<typename V> bool encode(size_t index, V& v) const
29990                 {
29991                         if(index != type) {return false;} return v(ref_nested());
29992
29993                 }
29994                 private:
29995                 size_t type {0};
29996
29997         };
29998         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29999         {
30000                 size_t get_index() const {return type;}
30001                 bool is_unknown() const { return type == 2; }
30002                 void clear() {type = 0;}
30003                 void select_id_BearerType() { set(reject); type=1;}
30004                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30005                 template<typename V>  bool decode(V& v)
30006                 {
30007                         clear();
30008                         if(!v(ref_nested())) return false;
30009                         if(equal(reject)) { type = 1; return true; }
30010                         else { type = 2; return true;}
30011                         return false;
30012
30013                 }
30014                 template<typename V> bool encode(V& v) const
30015                 {
30016                         return v(ref_nested());
30017
30018                 }
30019                 protected:
30020                 template<typename V>  bool decode(size_t index, V& v)
30021                 {
30022                         clear();
30023                         switch(index)
30024                         {
30025                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
30026                         case 2: type = 2; return v(ref_nested());
30027                         ref_nested().clear();
30028                         }
30029                         return false;
30030
30031                 }
30032                 template<typename V> bool encode(size_t index, V& v) const
30033                 {
30034                         if(index != type) {return false;} return v(ref_nested());
30035
30036                 }
30037                 private:
30038                 size_t type {0};
30039
30040         };
30041         struct Extension_t : asn::typefield<true>
30042         {
30043                 ~Extension_t()  {clear();}
30044                 size_t get_index() const {return type;}
30045                 BearerType& select_id_BearerType() { return set<BearerType>(1); }
30046                 BearerType const* get_id_BearerType() const { return get<BearerType>(1); }
30047                 bool is_unknown() const { return type == 2; }
30048                 void clear()
30049                 {
30050                         switch(type)
30051                         {
30052                         case 1: var.destroy<BearerType>(); break;
30053                         }
30054                         type = 0; ref_nested().clear();
30055                 }
30056                 template<typename V> static inline void enumerate(V& v)
30057                 {
30058                         v.template operator()<BearerType>(1);
30059
30060                 }
30061                 protected:
30062                 template<typename V> bool decode(size_t index, V& v)
30063                 {
30064                         clear();
30065                         switch(index)
30066                         {
30067                         case 1: v(select_id_BearerType()); return true;
30068                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30069                         }
30070                         return false;
30071
30072                 }
30073                 template<typename V> bool encode(size_t index, V& v) const
30074                 {
30075                         if(index != type) return false;
30076                         switch(type)
30077                         {
30078                         case 1: v(var.as<BearerType>()); return true;
30079                         }
30080                         return false;
30081
30082                 }
30083                 private:
30084                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30085                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30086                 union union_type
30087                 {
30088                         char dummy1[sizeof(BearerType)];
30089
30090                 };
30091                 asn::variant<sizeof(union_type)> var;
30092                 size_t type {0};
30093
30094         };
30095         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30096         {
30097                 size_t get_index() const {return type;}
30098                 bool is_unknown() const { return type == 2; }
30099                 void clear() {type = 0;}
30100                 void select_id_BearerType() { set(optional); type=1;}
30101                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30102                 template<typename V>  bool decode(V& v)
30103                 {
30104                         clear();
30105                         if(!v(ref_nested())) return false;
30106                         if(equal(optional)) { type = 1; return true; }
30107                         else { type = 2; return true;}
30108                         return false;
30109
30110                 }
30111                 template<typename V> bool encode(V& v) const
30112                 {
30113                         return v(ref_nested());
30114
30115                 }
30116                 protected:
30117                 template<typename V>  bool decode(size_t index, V& v)
30118                 {
30119                         clear();
30120                         switch(index)
30121                         {
30122                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
30123                         case 2: type = 2; return v(ref_nested());
30124                         ref_nested().clear();
30125                         }
30126                         return false;
30127
30128                 }
30129                 template<typename V> bool encode(size_t index, V& v) const
30130                 {
30131                         if(index != type) {return false;} return v(ref_nested());
30132
30133                 }
30134                 private:
30135                 size_t type {0};
30136
30137         };
30138
30139 };
30140 /*
30141 E-RABs-ToBeSetup-Item ::= SEQUENCE {
30142         e-RAB-ID                                        E-RAB-ID,
30143         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
30144         dL-Forwarding                                   DL-Forwarding                                                                                                   OPTIONAL,
30145         uL-GTPtunnelEndpoint                    GTPtunnelEndpoint,
30146         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeSetup-ItemExtIEs} } OPTIONAL,
30147         ...
30148 }
30149 */
30150
30151 struct E_RABs_ToBeSetup_Item : asn::sequence<5, 0, true, 2>
30152 {
30153         static constexpr const char* name() {return "E-RABs-ToBeSetup-Item";}
30154         using parent_t = asn::sequence<5, 0, true, 2>;
30155         struct e_RAB_ID_t : E_RAB_ID
30156         {
30157                 static constexpr const char* name() {return "e_RAB_ID_t";}
30158                 using parent_t = E_RAB_ID;
30159
30160         };
30161         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30162         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30163         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
30164         {
30165                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
30166                 using parent_t = E_RAB_Level_QoS_Parameters;
30167
30168         };
30169         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
30170         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
30171         struct dL_Forwarding_t : DL_Forwarding
30172         {
30173                 static constexpr const char* name() {return "dL_Forwarding_t";}
30174                 using parent_t = DL_Forwarding;
30175                 static constexpr bool optional = true;
30176
30177         };
30178         dL_Forwarding_t& set_dL_Forwarding() { dL_Forwarding.setpresent(true); return dL_Forwarding;}
30179         dL_Forwarding_t const* get_dL_Forwarding() const {return dL_Forwarding.is_valid() ? &dL_Forwarding : nullptr;}
30180         struct uL_GTPtunnelEndpoint_t : GTPtunnelEndpoint
30181         {
30182                 static constexpr const char* name() {return "uL_GTPtunnelEndpoint_t";}
30183                 using parent_t = GTPtunnelEndpoint;
30184
30185         };
30186         uL_GTPtunnelEndpoint_t& ref_uL_GTPtunnelEndpoint() {return uL_GTPtunnelEndpoint;}
30187         uL_GTPtunnelEndpoint_t const& ref_uL_GTPtunnelEndpoint() const {return uL_GTPtunnelEndpoint;}
30188         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>
30189         {
30190                 static constexpr const char* name() {return "iE_Extensions_t";}
30191                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetup_ItemExtIEs>;
30192                 static constexpr bool optional = true;
30193
30194         };
30195         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30196         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30197         template<typename V> void decode(V& v)
30198         {
30199                 v(e_RAB_ID);
30200                 v(e_RAB_Level_QoS_Parameters);
30201                 v(dL_Forwarding);
30202                 v(uL_GTPtunnelEndpoint);
30203                 v(iE_Extensions);
30204
30205         };
30206         template<typename V> void encode(V& v) const
30207         {
30208                 v(e_RAB_ID);
30209                 v(e_RAB_Level_QoS_Parameters);
30210                 v(dL_Forwarding);
30211                 v(uL_GTPtunnelEndpoint);
30212                 v(iE_Extensions);
30213
30214         };
30215         void clear()
30216         {
30217                 e_RAB_ID.clear();
30218                 e_RAB_Level_QoS_Parameters.clear();
30219                 dL_Forwarding.clear();
30220                 uL_GTPtunnelEndpoint.clear();
30221                 iE_Extensions.clear();
30222
30223         };
30224         private:
30225         e_RAB_ID_t      e_RAB_ID;
30226         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
30227         dL_Forwarding_t dL_Forwarding;
30228         uL_GTPtunnelEndpoint_t  uL_GTPtunnelEndpoint;
30229         iE_Extensions_t iE_Extensions;
30230
30231 };
30232 /*
30233 E-RABs-ToBeSetup-ItemIEs        X2AP-PROTOCOL-IES ::= {
30234         { ID id-E-RABs-ToBeSetup-Item    CRITICALITY ignore     TYPE E-RABs-ToBeSetup-Item      PRESENCE mandatory },
30235         ...
30236 }
30237 */
30238
30239 struct E_RABs_ToBeSetup_ItemIEs
30240 {
30241         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30242         {
30243                 size_t get_index() const {return type;}
30244                 bool is_unknown() const { return type == 2; }
30245                 void clear() {type = 0;}
30246                 void select_id_E_RABs_ToBeSetup_Item() { set(id_E_RABs_ToBeSetup_Item); type=1;}
30247                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30248                 template<typename V>  bool decode(V& v)
30249                 {
30250                         clear();
30251                         if(!v(ref_nested())) return false;
30252                         if(equal(id_E_RABs_ToBeSetup_Item)) { type = 1; return true; }
30253                         else { type = 2; return true;}
30254                         return false;
30255
30256                 }
30257                 template<typename V> bool encode(V& v) const
30258                 {
30259                         return v(ref_nested());
30260
30261                 }
30262                 protected:
30263                 template<typename V>  bool decode(size_t index, V& v)
30264                 {
30265                         clear();
30266                         switch(index)
30267                         {
30268                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeSetup_Item);} return false;
30269                         case 2: type = 2; return v(ref_nested());
30270                         ref_nested().clear();
30271                         }
30272                         return false;
30273
30274                 }
30275                 template<typename V> bool encode(size_t index, V& v) const
30276                 {
30277                         if(index != type) {return false;} return v(ref_nested());
30278
30279                 }
30280                 private:
30281                 size_t type {0};
30282
30283         };
30284         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30285         {
30286                 size_t get_index() const {return type;}
30287                 bool is_unknown() const { return type == 2; }
30288                 void clear() {type = 0;}
30289                 void select_id_E_RABs_ToBeSetup_Item() { set(ignore); type=1;}
30290                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30291                 template<typename V>  bool decode(V& v)
30292                 {
30293                         clear();
30294                         if(!v(ref_nested())) return false;
30295                         if(equal(ignore)) { type = 1; return true; }
30296                         else { type = 2; return true;}
30297                         return false;
30298
30299                 }
30300                 template<typename V> bool encode(V& v) const
30301                 {
30302                         return v(ref_nested());
30303
30304                 }
30305                 protected:
30306                 template<typename V>  bool decode(size_t index, V& v)
30307                 {
30308                         clear();
30309                         switch(index)
30310                         {
30311                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
30312                         case 2: type = 2; return v(ref_nested());
30313                         ref_nested().clear();
30314                         }
30315                         return false;
30316
30317                 }
30318                 template<typename V> bool encode(size_t index, V& v) const
30319                 {
30320                         if(index != type) {return false;} return v(ref_nested());
30321
30322                 }
30323                 private:
30324                 size_t type {0};
30325
30326         };
30327         struct Value_t : asn::typefield<true>
30328         {
30329                 ~Value_t()      {clear();}
30330                 size_t get_index() const {return type;}
30331                 E_RABs_ToBeSetup_Item& select_id_E_RABs_ToBeSetup_Item() { return set<E_RABs_ToBeSetup_Item>(1); }
30332                 E_RABs_ToBeSetup_Item const* get_id_E_RABs_ToBeSetup_Item() const { return get<E_RABs_ToBeSetup_Item>(1); }
30333                 bool is_unknown() const { return type == 2; }
30334                 void clear()
30335                 {
30336                         switch(type)
30337                         {
30338                         case 1: var.destroy<E_RABs_ToBeSetup_Item>(); break;
30339                         }
30340                         type = 0; ref_nested().clear();
30341                 }
30342                 template<typename V> static inline void enumerate(V& v)
30343                 {
30344                         v.template operator()<E_RABs_ToBeSetup_Item>(1);
30345
30346                 }
30347                 protected:
30348                 template<typename V> bool decode(size_t index, V& v)
30349                 {
30350                         clear();
30351                         switch(index)
30352                         {
30353                         case 1: v(select_id_E_RABs_ToBeSetup_Item()); return true;
30354                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30355                         }
30356                         return false;
30357
30358                 }
30359                 template<typename V> bool encode(size_t index, V& v) const
30360                 {
30361                         if(index != type) return false;
30362                         switch(type)
30363                         {
30364                         case 1: v(var.as<E_RABs_ToBeSetup_Item>()); return true;
30365                         }
30366                         return false;
30367
30368                 }
30369                 private:
30370                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30371                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30372                 union union_type
30373                 {
30374                         char dummy1[sizeof(E_RABs_ToBeSetup_Item)];
30375
30376                 };
30377                 asn::variant<sizeof(union_type)> var;
30378                 size_t type {0};
30379
30380         };
30381         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
30382         {
30383                 size_t get_index() const {return type;}
30384                 bool is_unknown() const { return type == 2; }
30385                 void clear() {type = 0;}
30386                 void select_id_E_RABs_ToBeSetup_Item() { set(mandatory); type=1;}
30387                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
30388                 template<typename V>  bool decode(V& v)
30389                 {
30390                         clear();
30391                         if(!v(ref_nested())) return false;
30392                         if(equal(mandatory)) { type = 1; return true; }
30393                         else { type = 2; return true;}
30394                         return false;
30395
30396                 }
30397                 template<typename V> bool encode(V& v) const
30398                 {
30399                         return v(ref_nested());
30400
30401                 }
30402                 protected:
30403                 template<typename V>  bool decode(size_t index, V& v)
30404                 {
30405                         clear();
30406                         switch(index)
30407                         {
30408                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30409                         case 2: type = 2; return v(ref_nested());
30410                         ref_nested().clear();
30411                         }
30412                         return false;
30413
30414                 }
30415                 template<typename V> bool encode(size_t index, V& v) const
30416                 {
30417                         if(index != type) {return false;} return v(ref_nested());
30418
30419                 }
30420                 private:
30421                 size_t type {0};
30422
30423         };
30424
30425 };
30426 /*
30427 E-RABs-ToBeSetup-List ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetup-ItemIEs} }
30428 */
30429
30430 struct E_RABs_ToBeSetup_List_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>
30431 {
30432         static constexpr const char* name() {return "E_RABs_ToBeSetup_List_elm";}
30433         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetup_ItemIEs>;
30434
30435 };
30436 struct E_RABs_ToBeSetup_List : asn::sequenceof<E_RABs_ToBeSetup_List_elm>
30437 {
30438         static constexpr const char* name() {return "E-RABs-ToBeSetup-List";}
30439         using parent_t = asn::sequenceof<E_RABs_ToBeSetup_List_elm>;
30440         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
30441
30442 };
30443 /*
30444 E-RABs-ToBeSetupRetrieve-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30445         { ID id-uL-GTPtunnelEndpoint            CRITICALITY reject      EXTENSION GTPtunnelEndpoint             PRESENCE mandatory}|
30446         { ID id-dL-Forwarding           CRITICALITY ignore      EXTENSION DL-Forwarding         PRESENCE optional },
30447         ...
30448 }
30449 */
30450
30451 struct E_RABs_ToBeSetupRetrieve_ItemExtIEs
30452 {
30453         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30454         {
30455                 size_t get_index() const {return type;}
30456                 bool is_unknown() const { return type == 3; }
30457                 void clear() {type = 0;}
30458                 void select_id_uL_GTPtunnelEndpoint() { set(id_uL_GTPtunnelEndpoint); type=1;}
30459                 void select_id_dL_Forwarding() { set(id_dL_Forwarding); type=2;}
30460                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30461                 template<typename V>  bool decode(V& v)
30462                 {
30463                         clear();
30464                         if(!v(ref_nested())) return false;
30465                         if(equal(id_uL_GTPtunnelEndpoint)) { type = 1; return true; }
30466                         else if(equal(id_dL_Forwarding)) { type = 2; return true; }
30467                         else { type = 3; return true;}
30468                         return false;
30469
30470                 }
30471                 template<typename V> bool encode(V& v) const
30472                 {
30473                         return v(ref_nested());
30474
30475                 }
30476                 protected:
30477                 template<typename V>  bool decode(size_t index, V& v)
30478                 {
30479                         clear();
30480                         switch(index)
30481                         {
30482                         case 1: type = 1; if(v(ref_nested())) { return equal(id_uL_GTPtunnelEndpoint);} return false;
30483                         case 2: type = 2; if(v(ref_nested())) { return equal(id_dL_Forwarding);} return false;
30484                         case 3: type = 3; return v(ref_nested());
30485                         ref_nested().clear();
30486                         }
30487                         return false;
30488
30489                 }
30490                 template<typename V> bool encode(size_t index, V& v) const
30491                 {
30492                         if(index != type) {return false;} return v(ref_nested());
30493
30494                 }
30495                 private:
30496                 size_t type {0};
30497
30498         };
30499         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30500         {
30501                 size_t get_index() const {return type;}
30502                 bool is_unknown() const { return type == 3; }
30503                 void clear() {type = 0;}
30504                 void select_id_uL_GTPtunnelEndpoint() { set(reject); type=1;}
30505                 void select_id_dL_Forwarding() { set(ignore); type=2;}
30506                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30507                 template<typename V>  bool decode(V& v)
30508                 {
30509                         clear();
30510                         if(!v(ref_nested())) return false;
30511                         if(equal(reject)) { type = 1; return true; }
30512                         else if(equal(ignore)) { type = 2; return true; }
30513                         else { type = 3; return true;}
30514                         return false;
30515
30516                 }
30517                 template<typename V> bool encode(V& v) const
30518                 {
30519                         return v(ref_nested());
30520
30521                 }
30522                 protected:
30523                 template<typename V>  bool decode(size_t index, V& v)
30524                 {
30525                         clear();
30526                         switch(index)
30527                         {
30528                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
30529                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
30530                         case 3: type = 3; return v(ref_nested());
30531                         ref_nested().clear();
30532                         }
30533                         return false;
30534
30535                 }
30536                 template<typename V> bool encode(size_t index, V& v) const
30537                 {
30538                         if(index != type) {return false;} return v(ref_nested());
30539
30540                 }
30541                 private:
30542                 size_t type {0};
30543
30544         };
30545         struct Extension_t : asn::typefield<true>
30546         {
30547                 ~Extension_t()  {clear();}
30548                 size_t get_index() const {return type;}
30549                 GTPtunnelEndpoint& select_id_uL_GTPtunnelEndpoint() { return set<GTPtunnelEndpoint>(1); }
30550                 GTPtunnelEndpoint const* get_id_uL_GTPtunnelEndpoint() const { return get<GTPtunnelEndpoint>(1); }
30551                 DL_Forwarding& select_id_dL_Forwarding() { return set<DL_Forwarding>(2); }
30552                 DL_Forwarding const* get_id_dL_Forwarding() const { return get<DL_Forwarding>(2); }
30553                 bool is_unknown() const { return type == 3; }
30554                 void clear()
30555                 {
30556                         switch(type)
30557                         {
30558                         case 1: var.destroy<GTPtunnelEndpoint>(); break;
30559                         case 2: var.destroy<DL_Forwarding>(); break;
30560                         }
30561                         type = 0; ref_nested().clear();
30562                 }
30563                 template<typename V> static inline void enumerate(V& v)
30564                 {
30565                         v.template operator()<GTPtunnelEndpoint>(1);
30566                         v.template operator()<DL_Forwarding>(2);
30567
30568                 }
30569                 protected:
30570                 template<typename V> bool decode(size_t index, V& v)
30571                 {
30572                         clear();
30573                         switch(index)
30574                         {
30575                         case 1: v(select_id_uL_GTPtunnelEndpoint()); return true;
30576                         case 2: v(select_id_dL_Forwarding()); return true;
30577                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
30578                         }
30579                         return false;
30580
30581                 }
30582                 template<typename V> bool encode(size_t index, V& v) const
30583                 {
30584                         if(index != type) return false;
30585                         switch(type)
30586                         {
30587                         case 1: v(var.as<GTPtunnelEndpoint>()); return true;
30588                         case 2: v(var.as<DL_Forwarding>()); return true;
30589                         }
30590                         return false;
30591
30592                 }
30593                 private:
30594                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30595                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30596                 union union_type
30597                 {
30598                         char dummy1[sizeof(DL_Forwarding)];
30599                         char dummy2[sizeof(GTPtunnelEndpoint)];
30600
30601                 };
30602                 asn::variant<sizeof(union_type)> var;
30603                 size_t type {0};
30604
30605         };
30606         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30607         {
30608                 size_t get_index() const {return type;}
30609                 bool is_unknown() const { return type == 3; }
30610                 void clear() {type = 0;}
30611                 void select_id_uL_GTPtunnelEndpoint() { set(mandatory); type=1;}
30612                 void select_id_dL_Forwarding() { set(optional); type=2;}
30613                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30614                 template<typename V>  bool decode(V& v)
30615                 {
30616                         clear();
30617                         if(!v(ref_nested())) return false;
30618                         if(equal(mandatory)) { type = 1; return true; }
30619                         else if(equal(optional)) { type = 2; return true; }
30620                         else { type = 3; return true;}
30621                         return false;
30622
30623                 }
30624                 template<typename V> bool encode(V& v) const
30625                 {
30626                         return v(ref_nested());
30627
30628                 }
30629                 protected:
30630                 template<typename V>  bool decode(size_t index, V& v)
30631                 {
30632                         clear();
30633                         switch(index)
30634                         {
30635                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30636                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
30637                         case 3: type = 3; return v(ref_nested());
30638                         ref_nested().clear();
30639                         }
30640                         return false;
30641
30642                 }
30643                 template<typename V> bool encode(size_t index, V& v) const
30644                 {
30645                         if(index != type) {return false;} return v(ref_nested());
30646
30647                 }
30648                 private:
30649                 size_t type {0};
30650
30651         };
30652
30653 };
30654 /*
30655 E-RABs-ToBeSetupRetrieve-Item ::= SEQUENCE {
30656         e-RAB-ID                                                E-RAB-ID,
30657         e-RAB-Level-QoS-Parameters              E-RAB-Level-QoS-Parameters,
30658         bearerType                                              BearerType      OPTIONAL,
30659         iE-Extensions                                   ProtocolExtensionContainer { {E-RABs-ToBeSetupRetrieve-ItemExtIEs} } OPTIONAL,
30660         ...
30661 }
30662 */
30663
30664 struct E_RABs_ToBeSetupRetrieve_Item : asn::sequence<4, 0, true, 2>
30665 {
30666         static constexpr const char* name() {return "E-RABs-ToBeSetupRetrieve-Item";}
30667         using parent_t = asn::sequence<4, 0, true, 2>;
30668         struct e_RAB_ID_t : E_RAB_ID
30669         {
30670                 static constexpr const char* name() {return "e_RAB_ID_t";}
30671                 using parent_t = E_RAB_ID;
30672
30673         };
30674         e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30675         e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30676         struct e_RAB_Level_QoS_Parameters_t : E_RAB_Level_QoS_Parameters
30677         {
30678                 static constexpr const char* name() {return "e_RAB_Level_QoS_Parameters_t";}
30679                 using parent_t = E_RAB_Level_QoS_Parameters;
30680
30681         };
30682         e_RAB_Level_QoS_Parameters_t& ref_e_RAB_Level_QoS_Parameters() {return e_RAB_Level_QoS_Parameters;}
30683         e_RAB_Level_QoS_Parameters_t const& ref_e_RAB_Level_QoS_Parameters() const {return e_RAB_Level_QoS_Parameters;}
30684         struct bearerType_t : BearerType
30685         {
30686                 static constexpr const char* name() {return "bearerType_t";}
30687                 using parent_t = BearerType;
30688                 static constexpr bool optional = true;
30689
30690         };
30691         bearerType_t& set_bearerType() { bearerType.setpresent(true); return bearerType;}
30692         bearerType_t const* get_bearerType() const {return bearerType.is_valid() ? &bearerType : nullptr;}
30693         struct iE_Extensions_t : ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>
30694         {
30695                 static constexpr const char* name() {return "iE_Extensions_t";}
30696                 using parent_t = ProtocolExtensionContainer<E_RABs_ToBeSetupRetrieve_ItemExtIEs>;
30697                 static constexpr bool optional = true;
30698
30699         };
30700         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30701         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30702         template<typename V> void decode(V& v)
30703         {
30704                 v(e_RAB_ID);
30705                 v(e_RAB_Level_QoS_Parameters);
30706                 v(bearerType);
30707                 v(iE_Extensions);
30708
30709         };
30710         template<typename V> void encode(V& v) const
30711         {
30712                 v(e_RAB_ID);
30713                 v(e_RAB_Level_QoS_Parameters);
30714                 v(bearerType);
30715                 v(iE_Extensions);
30716
30717         };
30718         void clear()
30719         {
30720                 e_RAB_ID.clear();
30721                 e_RAB_Level_QoS_Parameters.clear();
30722                 bearerType.clear();
30723                 iE_Extensions.clear();
30724
30725         };
30726         private:
30727         e_RAB_ID_t      e_RAB_ID;
30728         e_RAB_Level_QoS_Parameters_t    e_RAB_Level_QoS_Parameters;
30729         bearerType_t    bearerType;
30730         iE_Extensions_t iE_Extensions;
30731
30732 };
30733 /*
30734 E-RABs-ToBeSetupRetrieve-ItemIEs        X2AP-PROTOCOL-IES ::= {
30735         { ID id-E-RABs-ToBeSetupRetrieve-Item   CRITICALITY ignore      TYPE E-RABs-ToBeSetupRetrieve-Item      PRESENCE mandatory},
30736         ...
30737 }
30738 */
30739
30740 struct E_RABs_ToBeSetupRetrieve_ItemIEs
30741 {
30742         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30743         {
30744                 size_t get_index() const {return type;}
30745                 bool is_unknown() const { return type == 2; }
30746                 void clear() {type = 0;}
30747                 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(id_E_RABs_ToBeSetupRetrieve_Item); type=1;}
30748                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30749                 template<typename V>  bool decode(V& v)
30750                 {
30751                         clear();
30752                         if(!v(ref_nested())) return false;
30753                         if(equal(id_E_RABs_ToBeSetupRetrieve_Item)) { type = 1; return true; }
30754                         else { type = 2; return true;}
30755                         return false;
30756
30757                 }
30758                 template<typename V> bool encode(V& v) const
30759                 {
30760                         return v(ref_nested());
30761
30762                 }
30763                 protected:
30764                 template<typename V>  bool decode(size_t index, V& v)
30765                 {
30766                         clear();
30767                         switch(index)
30768                         {
30769                         case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABs_ToBeSetupRetrieve_Item);} return false;
30770                         case 2: type = 2; return v(ref_nested());
30771                         ref_nested().clear();
30772                         }
30773                         return false;
30774
30775                 }
30776                 template<typename V> bool encode(size_t index, V& v) const
30777                 {
30778                         if(index != type) {return false;} return v(ref_nested());
30779
30780                 }
30781                 private:
30782                 size_t type {0};
30783
30784         };
30785         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30786         {
30787                 size_t get_index() const {return type;}
30788                 bool is_unknown() const { return type == 2; }
30789                 void clear() {type = 0;}
30790                 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(ignore); type=1;}
30791                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30792                 template<typename V>  bool decode(V& v)
30793                 {
30794                         clear();
30795                         if(!v(ref_nested())) return false;
30796                         if(equal(ignore)) { type = 1; return true; }
30797                         else { type = 2; return true;}
30798                         return false;
30799
30800                 }
30801                 template<typename V> bool encode(V& v) const
30802                 {
30803                         return v(ref_nested());
30804
30805                 }
30806                 protected:
30807                 template<typename V>  bool decode(size_t index, V& v)
30808                 {
30809                         clear();
30810                         switch(index)
30811                         {
30812                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
30813                         case 2: type = 2; return v(ref_nested());
30814                         ref_nested().clear();
30815                         }
30816                         return false;
30817
30818                 }
30819                 template<typename V> bool encode(size_t index, V& v) const
30820                 {
30821                         if(index != type) {return false;} return v(ref_nested());
30822
30823                 }
30824                 private:
30825                 size_t type {0};
30826
30827         };
30828         struct Value_t : asn::typefield<true>
30829         {
30830                 ~Value_t()      {clear();}
30831                 size_t get_index() const {return type;}
30832                 E_RABs_ToBeSetupRetrieve_Item& select_id_E_RABs_ToBeSetupRetrieve_Item() { return set<E_RABs_ToBeSetupRetrieve_Item>(1); }
30833                 E_RABs_ToBeSetupRetrieve_Item const* get_id_E_RABs_ToBeSetupRetrieve_Item() const { return get<E_RABs_ToBeSetupRetrieve_Item>(1); }
30834                 bool is_unknown() const { return type == 2; }
30835                 void clear()
30836                 {
30837                         switch(type)
30838                         {
30839                         case 1: var.destroy<E_RABs_ToBeSetupRetrieve_Item>(); break;
30840                         }
30841                         type = 0; ref_nested().clear();
30842                 }
30843                 template<typename V> static inline void enumerate(V& v)
30844                 {
30845                         v.template operator()<E_RABs_ToBeSetupRetrieve_Item>(1);
30846
30847                 }
30848                 protected:
30849                 template<typename V> bool decode(size_t index, V& v)
30850                 {
30851                         clear();
30852                         switch(index)
30853                         {
30854                         case 1: v(select_id_E_RABs_ToBeSetupRetrieve_Item()); return true;
30855                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
30856                         }
30857                         return false;
30858
30859                 }
30860                 template<typename V> bool encode(size_t index, V& v) const
30861                 {
30862                         if(index != type) return false;
30863                         switch(type)
30864                         {
30865                         case 1: v(var.as<E_RABs_ToBeSetupRetrieve_Item>()); return true;
30866                         }
30867                         return false;
30868
30869                 }
30870                 private:
30871                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
30872                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
30873                 union union_type
30874                 {
30875                         char dummy1[sizeof(E_RABs_ToBeSetupRetrieve_Item)];
30876
30877                 };
30878                 asn::variant<sizeof(union_type)> var;
30879                 size_t type {0};
30880
30881         };
30882         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
30883         {
30884                 size_t get_index() const {return type;}
30885                 bool is_unknown() const { return type == 2; }
30886                 void clear() {type = 0;}
30887                 void select_id_E_RABs_ToBeSetupRetrieve_Item() { set(mandatory); type=1;}
30888                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
30889                 template<typename V>  bool decode(V& v)
30890                 {
30891                         clear();
30892                         if(!v(ref_nested())) return false;
30893                         if(equal(mandatory)) { type = 1; return true; }
30894                         else { type = 2; return true;}
30895                         return false;
30896
30897                 }
30898                 template<typename V> bool encode(V& v) const
30899                 {
30900                         return v(ref_nested());
30901
30902                 }
30903                 protected:
30904                 template<typename V>  bool decode(size_t index, V& v)
30905                 {
30906                         clear();
30907                         switch(index)
30908                         {
30909                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
30910                         case 2: type = 2; return v(ref_nested());
30911                         ref_nested().clear();
30912                         }
30913                         return false;
30914
30915                 }
30916                 template<typename V> bool encode(size_t index, V& v) const
30917                 {
30918                         if(index != type) {return false;} return v(ref_nested());
30919
30920                 }
30921                 private:
30922                 size_t type {0};
30923
30924         };
30925
30926 };
30927 /*
30928 E-RABs-ToBeSetup-ListRetrieve ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RABs-ToBeSetupRetrieve-ItemIEs} }
30929 */
30930
30931 struct E_RABs_ToBeSetup_ListRetrieve_elm : ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>
30932 {
30933         static constexpr const char* name() {return "E_RABs_ToBeSetup_ListRetrieve_elm";}
30934         using parent_t = ProtocolIE_Single_Container<E_RABs_ToBeSetupRetrieve_ItemIEs>;
30935
30936 };
30937 struct E_RABs_ToBeSetup_ListRetrieve : asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>
30938 {
30939         static constexpr const char* name() {return "E-RABs-ToBeSetup-ListRetrieve";}
30940         using parent_t = asn::sequenceof<E_RABs_ToBeSetup_ListRetrieve_elm>;
30941         using constraint_t = asn::constraints<false,asn::span<1,  maxnoofBearers >>;
30942
30943 };
30944 /*
30945 ENB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
30946         ...
30947 }
30948 */
30949
30950 struct ENB_ENDCConfigUpdateAckIEs
30951 {
30952         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
30953         {
30954                 size_t get_index() const {return type;}
30955                 bool is_unknown() const { return type == 1; }
30956                 void clear() {type = 0;}
30957                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
30958                 template<typename V>  bool decode(V& v)
30959                 {
30960                         clear();
30961                         if(!v(ref_nested())) return false;
30962                         { type = 1; return true;}
30963                         return false;
30964
30965                 }
30966                 template<typename V> bool encode(V& v) const
30967                 {
30968                         return v(ref_nested());
30969
30970                 }
30971                 protected:
30972                 template<typename V>  bool decode(size_t index, V& v)
30973                 {
30974                         clear();
30975                         switch(index)
30976                         {
30977                         case 1: type = 1; return v(ref_nested());
30978                         ref_nested().clear();
30979                         }
30980                         return false;
30981
30982                 }
30983                 template<typename V> bool encode(size_t index, V& v) const
30984                 {
30985                         if(index != type) {return false;} return v(ref_nested());
30986
30987                 }
30988                 private:
30989                 size_t type {0};
30990
30991         };
30992         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
30993         {
30994                 size_t get_index() const {return type;}
30995                 bool is_unknown() const { return type == 1; }
30996                 void clear() {type = 0;}
30997                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
30998                 template<typename V>  bool decode(V& v)
30999                 {
31000                         clear();
31001                         if(!v(ref_nested())) return false;
31002                         { type = 1; return true;}
31003                         return false;
31004
31005                 }
31006                 template<typename V> bool encode(V& v) const
31007                 {
31008                         return v(ref_nested());
31009
31010                 }
31011                 protected:
31012                 template<typename V>  bool decode(size_t index, V& v)
31013                 {
31014                         clear();
31015                         switch(index)
31016                         {
31017                         case 1: type = 1; return v(ref_nested());
31018                         ref_nested().clear();
31019                         }
31020                         return false;
31021
31022                 }
31023                 template<typename V> bool encode(size_t index, V& v) const
31024                 {
31025                         if(index != type) {return false;} return v(ref_nested());
31026
31027                 }
31028                 private:
31029                 size_t type {0};
31030
31031         };
31032         struct Value_t : asn::typefield<true>
31033         {
31034                 ~Value_t()      {clear();}
31035                 size_t get_index() const {return type;}
31036                 bool is_unknown() const { return type == 1; }
31037                 void clear()
31038                 {
31039                         type = 0; ref_nested().clear();
31040                 }
31041                 template<typename V> static inline void enumerate(V& v)
31042                 {
31043
31044                 }
31045                 protected:
31046                 template<typename V> bool decode(size_t index, V& v)
31047                 {
31048                         clear();
31049                         switch(index)
31050                         {
31051                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31052                         }
31053                         return false;
31054
31055                 }
31056                 template<typename V> bool encode(size_t index, V& v) const
31057                 {
31058                         if(index != type) return false;
31059                         return false;
31060
31061                 }
31062                 private:
31063                 size_t type {0};
31064
31065         };
31066         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
31067         {
31068                 size_t get_index() const {return type;}
31069                 bool is_unknown() const { return type == 1; }
31070                 void clear() {type = 0;}
31071                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
31072                 template<typename V>  bool decode(V& v)
31073                 {
31074                         clear();
31075                         if(!v(ref_nested())) return false;
31076                         { type = 1; return true;}
31077                         return false;
31078
31079                 }
31080                 template<typename V> bool encode(V& v) const
31081                 {
31082                         return v(ref_nested());
31083
31084                 }
31085                 protected:
31086                 template<typename V>  bool decode(size_t index, V& v)
31087                 {
31088                         clear();
31089                         switch(index)
31090                         {
31091                         case 1: type = 1; return v(ref_nested());
31092                         ref_nested().clear();
31093                         }
31094                         return false;
31095
31096                 }
31097                 template<typename V> bool encode(size_t index, V& v) const
31098                 {
31099                         if(index != type) {return false;} return v(ref_nested());
31100
31101                 }
31102                 private:
31103                 size_t type {0};
31104
31105         };
31106
31107 };
31108 /*
31109 FDD-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31110         ...
31111 }
31112 */
31113
31114 struct FDD_InfoNeighbourServedNRCell_Information_ExtIEs
31115 {
31116         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31117         {
31118                 size_t get_index() const {return type;}
31119                 bool is_unknown() const { return type == 1; }
31120                 void clear() {type = 0;}
31121                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31122                 template<typename V>  bool decode(V& v)
31123                 {
31124                         clear();
31125                         if(!v(ref_nested())) return false;
31126                         { type = 1; return true;}
31127                         return false;
31128
31129                 }
31130                 template<typename V> bool encode(V& v) const
31131                 {
31132                         return v(ref_nested());
31133
31134                 }
31135                 protected:
31136                 template<typename V>  bool decode(size_t index, V& v)
31137                 {
31138                         clear();
31139                         switch(index)
31140                         {
31141                         case 1: type = 1; return v(ref_nested());
31142                         ref_nested().clear();
31143                         }
31144                         return false;
31145
31146                 }
31147                 template<typename V> bool encode(size_t index, V& v) const
31148                 {
31149                         if(index != type) {return false;} return v(ref_nested());
31150
31151                 }
31152                 private:
31153                 size_t type {0};
31154
31155         };
31156         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31157         {
31158                 size_t get_index() const {return type;}
31159                 bool is_unknown() const { return type == 1; }
31160                 void clear() {type = 0;}
31161                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31162                 template<typename V>  bool decode(V& v)
31163                 {
31164                         clear();
31165                         if(!v(ref_nested())) return false;
31166                         { type = 1; return true;}
31167                         return false;
31168
31169                 }
31170                 template<typename V> bool encode(V& v) const
31171                 {
31172                         return v(ref_nested());
31173
31174                 }
31175                 protected:
31176                 template<typename V>  bool decode(size_t index, V& v)
31177                 {
31178                         clear();
31179                         switch(index)
31180                         {
31181                         case 1: type = 1; return v(ref_nested());
31182                         ref_nested().clear();
31183                         }
31184                         return false;
31185
31186                 }
31187                 template<typename V> bool encode(size_t index, V& v) const
31188                 {
31189                         if(index != type) {return false;} return v(ref_nested());
31190
31191                 }
31192                 private:
31193                 size_t type {0};
31194
31195         };
31196         struct Extension_t : asn::typefield<true>
31197         {
31198                 ~Extension_t()  {clear();}
31199                 size_t get_index() const {return type;}
31200                 bool is_unknown() const { return type == 1; }
31201                 void clear()
31202                 {
31203                         type = 0; ref_nested().clear();
31204                 }
31205                 template<typename V> static inline void enumerate(V& v)
31206                 {
31207
31208                 }
31209                 protected:
31210                 template<typename V> bool decode(size_t index, V& v)
31211                 {
31212                         clear();
31213                         switch(index)
31214                         {
31215                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31216                         }
31217                         return false;
31218
31219                 }
31220                 template<typename V> bool encode(size_t index, V& v) const
31221                 {
31222                         if(index != type) return false;
31223                         return false;
31224
31225                 }
31226                 private:
31227                 size_t type {0};
31228
31229         };
31230         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31231         {
31232                 size_t get_index() const {return type;}
31233                 bool is_unknown() const { return type == 1; }
31234                 void clear() {type = 0;}
31235                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31236                 template<typename V>  bool decode(V& v)
31237                 {
31238                         clear();
31239                         if(!v(ref_nested())) return false;
31240                         { type = 1; return true;}
31241                         return false;
31242
31243                 }
31244                 template<typename V> bool encode(V& v) const
31245                 {
31246                         return v(ref_nested());
31247
31248                 }
31249                 protected:
31250                 template<typename V>  bool decode(size_t index, V& v)
31251                 {
31252                         clear();
31253                         switch(index)
31254                         {
31255                         case 1: type = 1; return v(ref_nested());
31256                         ref_nested().clear();
31257                         }
31258                         return false;
31259
31260                 }
31261                 template<typename V> bool encode(size_t index, V& v) const
31262                 {
31263                         if(index != type) {return false;} return v(ref_nested());
31264
31265                 }
31266                 private:
31267                 size_t type {0};
31268
31269         };
31270
31271 };
31272 /*
31273 FDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
31274         ul-NRFreqInfo                   NRFreqInfo,
31275         dl-NRFreqInfo                   NRFreqInfo,
31276         iE-Extensions                   ProtocolExtensionContainer { {FDD-InfoNeighbourServedNRCell-Information-ExtIEs} }               OPTIONAL,
31277         ...
31278 }
31279 */
31280
31281 struct FDD_InfoNeighbourServedNRCell_Information : asn::sequence<3, 0, true, 1>
31282 {
31283         static constexpr const char* name() {return "FDD-InfoNeighbourServedNRCell-Information";}
31284         using parent_t = asn::sequence<3, 0, true, 1>;
31285         struct ul_NRFreqInfo_t : NRFreqInfo
31286         {
31287                 static constexpr const char* name() {return "ul_NRFreqInfo_t";}
31288                 using parent_t = NRFreqInfo;
31289
31290         };
31291         ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
31292         ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
31293         struct dl_NRFreqInfo_t : NRFreqInfo
31294         {
31295                 static constexpr const char* name() {return "dl_NRFreqInfo_t";}
31296                 using parent_t = NRFreqInfo;
31297
31298         };
31299         dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
31300         dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
31301         struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_Information_ExtIEs>
31302         {
31303                 static constexpr const char* name() {return "iE_Extensions_t";}
31304                 using parent_t = ProtocolExtensionContainer<FDD_InfoNeighbourServedNRCell_Information_ExtIEs>;
31305                 static constexpr bool optional = true;
31306
31307         };
31308         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31309         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31310         template<typename V> void decode(V& v)
31311         {
31312                 v(ul_NRFreqInfo);
31313                 v(dl_NRFreqInfo);
31314                 v(iE_Extensions);
31315
31316         };
31317         template<typename V> void encode(V& v) const
31318         {
31319                 v(ul_NRFreqInfo);
31320                 v(dl_NRFreqInfo);
31321                 v(iE_Extensions);
31322
31323         };
31324         void clear()
31325         {
31326                 ul_NRFreqInfo.clear();
31327                 dl_NRFreqInfo.clear();
31328                 iE_Extensions.clear();
31329
31330         };
31331         private:
31332         ul_NRFreqInfo_t ul_NRFreqInfo;
31333         dl_NRFreqInfo_t dl_NRFreqInfo;
31334         iE_Extensions_t iE_Extensions;
31335
31336 };
31337 /*
31338 TDD-InfoNeighbourServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31339         ...
31340 }
31341 */
31342
31343 struct TDD_InfoNeighbourServedNRCell_Information_ExtIEs
31344 {
31345         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31346         {
31347                 size_t get_index() const {return type;}
31348                 bool is_unknown() const { return type == 1; }
31349                 void clear() {type = 0;}
31350                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31351                 template<typename V>  bool decode(V& v)
31352                 {
31353                         clear();
31354                         if(!v(ref_nested())) return false;
31355                         { type = 1; return true;}
31356                         return false;
31357
31358                 }
31359                 template<typename V> bool encode(V& v) const
31360                 {
31361                         return v(ref_nested());
31362
31363                 }
31364                 protected:
31365                 template<typename V>  bool decode(size_t index, V& v)
31366                 {
31367                         clear();
31368                         switch(index)
31369                         {
31370                         case 1: type = 1; return v(ref_nested());
31371                         ref_nested().clear();
31372                         }
31373                         return false;
31374
31375                 }
31376                 template<typename V> bool encode(size_t index, V& v) const
31377                 {
31378                         if(index != type) {return false;} return v(ref_nested());
31379
31380                 }
31381                 private:
31382                 size_t type {0};
31383
31384         };
31385         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31386         {
31387                 size_t get_index() const {return type;}
31388                 bool is_unknown() const { return type == 1; }
31389                 void clear() {type = 0;}
31390                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31391                 template<typename V>  bool decode(V& v)
31392                 {
31393                         clear();
31394                         if(!v(ref_nested())) return false;
31395                         { type = 1; return true;}
31396                         return false;
31397
31398                 }
31399                 template<typename V> bool encode(V& v) const
31400                 {
31401                         return v(ref_nested());
31402
31403                 }
31404                 protected:
31405                 template<typename V>  bool decode(size_t index, V& v)
31406                 {
31407                         clear();
31408                         switch(index)
31409                         {
31410                         case 1: type = 1; return v(ref_nested());
31411                         ref_nested().clear();
31412                         }
31413                         return false;
31414
31415                 }
31416                 template<typename V> bool encode(size_t index, V& v) const
31417                 {
31418                         if(index != type) {return false;} return v(ref_nested());
31419
31420                 }
31421                 private:
31422                 size_t type {0};
31423
31424         };
31425         struct Extension_t : asn::typefield<true>
31426         {
31427                 ~Extension_t()  {clear();}
31428                 size_t get_index() const {return type;}
31429                 bool is_unknown() const { return type == 1; }
31430                 void clear()
31431                 {
31432                         type = 0; ref_nested().clear();
31433                 }
31434                 template<typename V> static inline void enumerate(V& v)
31435                 {
31436
31437                 }
31438                 protected:
31439                 template<typename V> bool decode(size_t index, V& v)
31440                 {
31441                         clear();
31442                         switch(index)
31443                         {
31444                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31445                         }
31446                         return false;
31447
31448                 }
31449                 template<typename V> bool encode(size_t index, V& v) const
31450                 {
31451                         if(index != type) return false;
31452                         return false;
31453
31454                 }
31455                 private:
31456                 size_t type {0};
31457
31458         };
31459         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31460         {
31461                 size_t get_index() const {return type;}
31462                 bool is_unknown() const { return type == 1; }
31463                 void clear() {type = 0;}
31464                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31465                 template<typename V>  bool decode(V& v)
31466                 {
31467                         clear();
31468                         if(!v(ref_nested())) return false;
31469                         { type = 1; return true;}
31470                         return false;
31471
31472                 }
31473                 template<typename V> bool encode(V& v) const
31474                 {
31475                         return v(ref_nested());
31476
31477                 }
31478                 protected:
31479                 template<typename V>  bool decode(size_t index, V& v)
31480                 {
31481                         clear();
31482                         switch(index)
31483                         {
31484                         case 1: type = 1; return v(ref_nested());
31485                         ref_nested().clear();
31486                         }
31487                         return false;
31488
31489                 }
31490                 template<typename V> bool encode(size_t index, V& v) const
31491                 {
31492                         if(index != type) {return false;} return v(ref_nested());
31493
31494                 }
31495                 private:
31496                 size_t type {0};
31497
31498         };
31499
31500 };
31501 /*
31502 TDD-InfoNeighbourServedNRCell-Information ::= SEQUENCE {
31503         nRFreqInfo                              NRFreqInfo,
31504         iE-Extensions                   ProtocolExtensionContainer { {TDD-InfoNeighbourServedNRCell-Information-ExtIEs} }               OPTIONAL,
31505         ...
31506 }
31507 */
31508
31509 struct TDD_InfoNeighbourServedNRCell_Information : asn::sequence<2, 0, true, 1>
31510 {
31511         static constexpr const char* name() {return "TDD-InfoNeighbourServedNRCell-Information";}
31512         using parent_t = asn::sequence<2, 0, true, 1>;
31513         struct nRFreqInfo_t : NRFreqInfo
31514         {
31515                 static constexpr const char* name() {return "nRFreqInfo_t";}
31516                 using parent_t = NRFreqInfo;
31517
31518         };
31519         nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
31520         nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
31521         struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_Information_ExtIEs>
31522         {
31523                 static constexpr const char* name() {return "iE_Extensions_t";}
31524                 using parent_t = ProtocolExtensionContainer<TDD_InfoNeighbourServedNRCell_Information_ExtIEs>;
31525                 static constexpr bool optional = true;
31526
31527         };
31528         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31529         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31530         template<typename V> void decode(V& v)
31531         {
31532                 v(nRFreqInfo);
31533                 v(iE_Extensions);
31534
31535         };
31536         template<typename V> void encode(V& v) const
31537         {
31538                 v(nRFreqInfo);
31539                 v(iE_Extensions);
31540
31541         };
31542         void clear()
31543         {
31544                 nRFreqInfo.clear();
31545                 iE_Extensions.clear();
31546
31547         };
31548         private:
31549         nRFreqInfo_t    nRFreqInfo;
31550         iE_Extensions_t iE_Extensions;
31551
31552 };
31553 /*
31554 NRNeighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31555         ...
31556 }
31557 */
31558
31559 struct NRNeighbour_Information_ExtIEs
31560 {
31561         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31562         {
31563                 size_t get_index() const {return type;}
31564                 bool is_unknown() const { return type == 1; }
31565                 void clear() {type = 0;}
31566                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31567                 template<typename V>  bool decode(V& v)
31568                 {
31569                         clear();
31570                         if(!v(ref_nested())) return false;
31571                         { type = 1; return true;}
31572                         return false;
31573
31574                 }
31575                 template<typename V> bool encode(V& v) const
31576                 {
31577                         return v(ref_nested());
31578
31579                 }
31580                 protected:
31581                 template<typename V>  bool decode(size_t index, V& v)
31582                 {
31583                         clear();
31584                         switch(index)
31585                         {
31586                         case 1: type = 1; return v(ref_nested());
31587                         ref_nested().clear();
31588                         }
31589                         return false;
31590
31591                 }
31592                 template<typename V> bool encode(size_t index, V& v) const
31593                 {
31594                         if(index != type) {return false;} return v(ref_nested());
31595
31596                 }
31597                 private:
31598                 size_t type {0};
31599
31600         };
31601         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31602         {
31603                 size_t get_index() const {return type;}
31604                 bool is_unknown() const { return type == 1; }
31605                 void clear() {type = 0;}
31606                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31607                 template<typename V>  bool decode(V& v)
31608                 {
31609                         clear();
31610                         if(!v(ref_nested())) return false;
31611                         { type = 1; return true;}
31612                         return false;
31613
31614                 }
31615                 template<typename V> bool encode(V& v) const
31616                 {
31617                         return v(ref_nested());
31618
31619                 }
31620                 protected:
31621                 template<typename V>  bool decode(size_t index, V& v)
31622                 {
31623                         clear();
31624                         switch(index)
31625                         {
31626                         case 1: type = 1; return v(ref_nested());
31627                         ref_nested().clear();
31628                         }
31629                         return false;
31630
31631                 }
31632                 template<typename V> bool encode(size_t index, V& v) const
31633                 {
31634                         if(index != type) {return false;} return v(ref_nested());
31635
31636                 }
31637                 private:
31638                 size_t type {0};
31639
31640         };
31641         struct Extension_t : asn::typefield<true>
31642         {
31643                 ~Extension_t()  {clear();}
31644                 size_t get_index() const {return type;}
31645                 bool is_unknown() const { return type == 1; }
31646                 void clear()
31647                 {
31648                         type = 0; ref_nested().clear();
31649                 }
31650                 template<typename V> static inline void enumerate(V& v)
31651                 {
31652
31653                 }
31654                 protected:
31655                 template<typename V> bool decode(size_t index, V& v)
31656                 {
31657                         clear();
31658                         switch(index)
31659                         {
31660                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31661                         }
31662                         return false;
31663
31664                 }
31665                 template<typename V> bool encode(size_t index, V& v) const
31666                 {
31667                         if(index != type) return false;
31668                         return false;
31669
31670                 }
31671                 private:
31672                 size_t type {0};
31673
31674         };
31675         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31676         {
31677                 size_t get_index() const {return type;}
31678                 bool is_unknown() const { return type == 1; }
31679                 void clear() {type = 0;}
31680                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31681                 template<typename V>  bool decode(V& v)
31682                 {
31683                         clear();
31684                         if(!v(ref_nested())) return false;
31685                         { type = 1; return true;}
31686                         return false;
31687
31688                 }
31689                 template<typename V> bool encode(V& v) const
31690                 {
31691                         return v(ref_nested());
31692
31693                 }
31694                 protected:
31695                 template<typename V>  bool decode(size_t index, V& v)
31696                 {
31697                         clear();
31698                         switch(index)
31699                         {
31700                         case 1: type = 1; return v(ref_nested());
31701                         ref_nested().clear();
31702                         }
31703                         return false;
31704
31705                 }
31706                 template<typename V> bool encode(size_t index, V& v) const
31707                 {
31708                         if(index != type) {return false;} return v(ref_nested());
31709
31710                 }
31711                 private:
31712                 size_t type {0};
31713
31714         };
31715
31716 };
31717 /*
31718 NRNeighbour-Information ::= SEQUENCE (SIZE (1.. maxofNRNeighbours))OF SEQUENCE {
31719         nrpCI                           NRPCI,
31720         nrCellID                                NRCGI,
31721         fiveGS-TAC                      FiveGS-TAC      OPTIONAL,
31722         configured-TAC          TAC                     OPTIONAL,
31723         measurementTimingConfiguration  OCTET STRING,
31724         nRNeighbourModeInfo                     CHOICE {
31725                 fdd             FDD-InfoNeighbourServedNRCell-Information,
31726                 tdd             TDD-InfoNeighbourServedNRCell-Information,
31727                 ...
31728         },
31729         iE-Extensions                                           ProtocolExtensionContainer { {NRNeighbour-Information-ExtIEs} } OPTIONAL,
31730         ...
31731 }
31732 */
31733
31734 struct NRNeighbour_Information_elm : asn::sequence<7, 0, true, 3>
31735 {
31736         static constexpr const char* name() {return "NRNeighbour_Information_elm";}
31737         using parent_t = asn::sequence<7, 0, true, 3>;
31738         struct nrpCI_t : NRPCI
31739         {
31740                 static constexpr const char* name() {return "nrpCI_t";}
31741                 using parent_t = NRPCI;
31742
31743         };
31744         nrpCI_t& ref_nrpCI() {return nrpCI;}
31745         nrpCI_t const& ref_nrpCI() const {return nrpCI;}
31746         struct nrCellID_t : NRCGI
31747         {
31748                 static constexpr const char* name() {return "nrCellID_t";}
31749                 using parent_t = NRCGI;
31750
31751         };
31752         nrCellID_t& ref_nrCellID() {return nrCellID;}
31753         nrCellID_t const& ref_nrCellID() const {return nrCellID;}
31754         struct fiveGS_TAC_t : FiveGS_TAC
31755         {
31756                 static constexpr const char* name() {return "fiveGS_TAC_t";}
31757                 using parent_t = FiveGS_TAC;
31758                 static constexpr bool optional = true;
31759
31760         };
31761         fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
31762         fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
31763         struct configured_TAC_t : TAC
31764         {
31765                 static constexpr const char* name() {return "configured_TAC_t";}
31766                 using parent_t = TAC;
31767                 static constexpr bool optional = true;
31768
31769         };
31770         configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
31771         configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
31772         struct measurementTimingConfiguration_t : asn::ostring<>
31773         {
31774                 static constexpr const char* name() {return "measurementTimingConfiguration_t";}
31775                 using parent_t = asn::ostring<>;
31776
31777         };
31778
31779         measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
31780         measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
31781         struct nRNeighbourModeInfo_t : asn::choice<2, 0, true>
31782         {
31783                 static constexpr const char* name() {return "nRNeighbourModeInfo_t";}
31784                 using parent_t = asn::choice<2, 0, true>;
31785                 index_type get_index() const {return index;}
31786                 bool is_unknown() const {return index == 3;}
31787                 void set_unknown() { set_index(3);  }
31788                 ~nRNeighbourModeInfo_t() {clear();}
31789                 struct fdd_t : FDD_InfoNeighbourServedNRCell_Information
31790                 {
31791                         static constexpr const char* name() {return "fdd_t";}
31792                         using parent_t = FDD_InfoNeighbourServedNRCell_Information;
31793
31794                 };
31795                 struct tdd_t : TDD_InfoNeighbourServedNRCell_Information
31796                 {
31797                         static constexpr const char* name() {return "tdd_t";}
31798                         using parent_t = TDD_InfoNeighbourServedNRCell_Information;
31799
31800                 };
31801                 void clear()
31802                 {
31803                         switch(get_index())
31804                         {
31805                         case 1: var.destroy<fdd_t>(); break;
31806                         case 2: var.destroy<tdd_t>(); break;
31807                         }
31808                         index = 0;
31809                         base::clear();
31810                 }
31811                 template<typename V> bool decode(size_t idx, V& v)
31812                 {
31813                         clear();
31814                         switch(idx)
31815                         {
31816                         case 1: set_index(1); return v(var.build<fdd_t>());
31817                         case 2: set_index(2); return v(var.build<tdd_t>());
31818                         }
31819                         return false;
31820
31821                 }
31822                 template<typename V> bool encode(V& v) const
31823                 {
31824                         switch(get_index())
31825                         {
31826                         case 1: return v(var.as<fdd_t>());
31827                         case 2: return v(var.as<tdd_t>());
31828                         }
31829                         return false;
31830                 }
31831                 template<typename V> static inline void enumerate(V& v)
31832                 {
31833                         v.template operator()<fdd_t>(1);
31834                         v.template operator()<tdd_t>(2);
31835
31836                 }
31837                 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
31838                 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
31839                 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
31840                 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
31841                 private:
31842                 void set_index(index_type i) {index = i; base::set();}
31843                 union union_type
31844                 {
31845                         char dummy1[sizeof(fdd_t)];
31846                         char dummy2[sizeof(tdd_t)];
31847
31848                 };
31849                 asn::variant<sizeof(union_type)>        var;
31850                 index_type      index {0};
31851         };
31852         nRNeighbourModeInfo_t& ref_nRNeighbourModeInfo() {return nRNeighbourModeInfo;}
31853         nRNeighbourModeInfo_t const& ref_nRNeighbourModeInfo() const {return nRNeighbourModeInfo;}
31854         struct iE_Extensions_t : ProtocolExtensionContainer<NRNeighbour_Information_ExtIEs>
31855         {
31856                 static constexpr const char* name() {return "iE_Extensions_t";}
31857                 using parent_t = ProtocolExtensionContainer<NRNeighbour_Information_ExtIEs>;
31858                 static constexpr bool optional = true;
31859
31860         };
31861         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31862         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31863         template<typename V> void decode(V& v)
31864         {
31865                 v(nrpCI);
31866                 v(nrCellID);
31867                 v(fiveGS_TAC);
31868                 v(configured_TAC);
31869                 v(measurementTimingConfiguration);
31870                 v(nRNeighbourModeInfo);
31871                 v(iE_Extensions);
31872
31873         };
31874         template<typename V> void encode(V& v) const
31875         {
31876                 v(nrpCI);
31877                 v(nrCellID);
31878                 v(fiveGS_TAC);
31879                 v(configured_TAC);
31880                 v(measurementTimingConfiguration);
31881                 v(nRNeighbourModeInfo);
31882                 v(iE_Extensions);
31883
31884         };
31885         void clear()
31886         {
31887                 nrpCI.clear();
31888                 nrCellID.clear();
31889                 fiveGS_TAC.clear();
31890                 configured_TAC.clear();
31891                 measurementTimingConfiguration.clear();
31892                 nRNeighbourModeInfo.clear();
31893                 iE_Extensions.clear();
31894
31895         };
31896         private:
31897         nrpCI_t nrpCI;
31898         nrCellID_t      nrCellID;
31899         fiveGS_TAC_t    fiveGS_TAC;
31900         configured_TAC_t        configured_TAC;
31901         measurementTimingConfiguration_t        measurementTimingConfiguration;
31902         nRNeighbourModeInfo_t   nRNeighbourModeInfo;
31903         iE_Extensions_t iE_Extensions;
31904
31905 };
31906 struct NRNeighbour_Information : asn::sequenceof<NRNeighbour_Information_elm>
31907 {
31908         static constexpr const char* name() {return "NRNeighbour-Information";}
31909         using parent_t = asn::sequenceof<NRNeighbour_Information_elm>;
31910         using constraint_t = asn::constraints<false,asn::span<1,  maxofNRNeighbours >>;
31911
31912 };
31913 /*
31914 ServedEUTRAcellsENDCX2Management-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31915         ...
31916 }
31917 */
31918
31919 struct ServedEUTRAcellsENDCX2Management_ExtIEs
31920 {
31921         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31922         {
31923                 size_t get_index() const {return type;}
31924                 bool is_unknown() const { return type == 1; }
31925                 void clear() {type = 0;}
31926                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31927                 template<typename V>  bool decode(V& v)
31928                 {
31929                         clear();
31930                         if(!v(ref_nested())) return false;
31931                         { type = 1; return true;}
31932                         return false;
31933
31934                 }
31935                 template<typename V> bool encode(V& v) const
31936                 {
31937                         return v(ref_nested());
31938
31939                 }
31940                 protected:
31941                 template<typename V>  bool decode(size_t index, V& v)
31942                 {
31943                         clear();
31944                         switch(index)
31945                         {
31946                         case 1: type = 1; return v(ref_nested());
31947                         ref_nested().clear();
31948                         }
31949                         return false;
31950
31951                 }
31952                 template<typename V> bool encode(size_t index, V& v) const
31953                 {
31954                         if(index != type) {return false;} return v(ref_nested());
31955
31956                 }
31957                 private:
31958                 size_t type {0};
31959
31960         };
31961         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31962         {
31963                 size_t get_index() const {return type;}
31964                 bool is_unknown() const { return type == 1; }
31965                 void clear() {type = 0;}
31966                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31967                 template<typename V>  bool decode(V& v)
31968                 {
31969                         clear();
31970                         if(!v(ref_nested())) return false;
31971                         { type = 1; return true;}
31972                         return false;
31973
31974                 }
31975                 template<typename V> bool encode(V& v) const
31976                 {
31977                         return v(ref_nested());
31978
31979                 }
31980                 protected:
31981                 template<typename V>  bool decode(size_t index, V& v)
31982                 {
31983                         clear();
31984                         switch(index)
31985                         {
31986                         case 1: type = 1; return v(ref_nested());
31987                         ref_nested().clear();
31988                         }
31989                         return false;
31990
31991                 }
31992                 template<typename V> bool encode(size_t index, V& v) const
31993                 {
31994                         if(index != type) {return false;} return v(ref_nested());
31995
31996                 }
31997                 private:
31998                 size_t type {0};
31999
32000         };
32001         struct Extension_t : asn::typefield<true>
32002         {
32003                 ~Extension_t()  {clear();}
32004                 size_t get_index() const {return type;}
32005                 bool is_unknown() const { return type == 1; }
32006                 void clear()
32007                 {
32008                         type = 0; ref_nested().clear();
32009                 }
32010                 template<typename V> static inline void enumerate(V& v)
32011                 {
32012
32013                 }
32014                 protected:
32015                 template<typename V> bool decode(size_t index, V& v)
32016                 {
32017                         clear();
32018                         switch(index)
32019                         {
32020                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32021                         }
32022                         return false;
32023
32024                 }
32025                 template<typename V> bool encode(size_t index, V& v) const
32026                 {
32027                         if(index != type) return false;
32028                         return false;
32029
32030                 }
32031                 private:
32032                 size_t type {0};
32033
32034         };
32035         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32036         {
32037                 size_t get_index() const {return type;}
32038                 bool is_unknown() const { return type == 1; }
32039                 void clear() {type = 0;}
32040                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32041                 template<typename V>  bool decode(V& v)
32042                 {
32043                         clear();
32044                         if(!v(ref_nested())) return false;
32045                         { type = 1; return true;}
32046                         return false;
32047
32048                 }
32049                 template<typename V> bool encode(V& v) const
32050                 {
32051                         return v(ref_nested());
32052
32053                 }
32054                 protected:
32055                 template<typename V>  bool decode(size_t index, V& v)
32056                 {
32057                         clear();
32058                         switch(index)
32059                         {
32060                         case 1: type = 1; return v(ref_nested());
32061                         ref_nested().clear();
32062                         }
32063                         return false;
32064
32065                 }
32066                 template<typename V> bool encode(size_t index, V& v) const
32067                 {
32068                         if(index != type) {return false;} return v(ref_nested());
32069
32070                 }
32071                 private:
32072                 size_t type {0};
32073
32074         };
32075
32076 };
32077 /*
32078 ServedEUTRAcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
32079         servedEUTRACellInfo                                     ServedCell-Information,
32080         nrNeighbourInfo                                         NRNeighbour-Information         OPTIONAL,
32081         iE-Extensions                                           ProtocolExtensionContainer { {ServedEUTRAcellsENDCX2Management-ExtIEs} } OPTIONAL,
32082         ...
32083 }
32084 */
32085
32086 struct ServedEUTRAcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
32087 {
32088         static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList_elm";}
32089         using parent_t = asn::sequence<3, 0, true, 2>;
32090         struct servedEUTRACellInfo_t : ServedCell_Information
32091         {
32092                 static constexpr const char* name() {return "servedEUTRACellInfo_t";}
32093                 using parent_t = ServedCell_Information;
32094
32095         };
32096         servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
32097         servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
32098         struct nrNeighbourInfo_t : NRNeighbour_Information
32099         {
32100                 static constexpr const char* name() {return "nrNeighbourInfo_t";}
32101                 using parent_t = NRNeighbour_Information;
32102                 static constexpr bool optional = true;
32103
32104         };
32105         nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
32106         nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
32107         struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_ExtIEs>
32108         {
32109                 static constexpr const char* name() {return "iE_Extensions_t";}
32110                 using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsENDCX2Management_ExtIEs>;
32111                 static constexpr bool optional = true;
32112
32113         };
32114         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32115         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32116         template<typename V> void decode(V& v)
32117         {
32118                 v(servedEUTRACellInfo);
32119                 v(nrNeighbourInfo);
32120                 v(iE_Extensions);
32121
32122         };
32123         template<typename V> void encode(V& v) const
32124         {
32125                 v(servedEUTRACellInfo);
32126                 v(nrNeighbourInfo);
32127                 v(iE_Extensions);
32128
32129         };
32130         void clear()
32131         {
32132                 servedEUTRACellInfo.clear();
32133                 nrNeighbourInfo.clear();
32134                 iE_Extensions.clear();
32135
32136         };
32137         private:
32138         servedEUTRACellInfo_t   servedEUTRACellInfo;
32139         nrNeighbourInfo_t       nrNeighbourInfo;
32140         iE_Extensions_t iE_Extensions;
32141
32142 };
32143 struct ServedEUTRAcellsENDCX2ManagementList : asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>
32144 {
32145         static constexpr const char* name() {return "ServedEUTRAcellsENDCX2ManagementList";}
32146         using parent_t = asn::sequenceof<ServedEUTRAcellsENDCX2ManagementList_elm>;
32147         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
32148
32149 };
32150 /*
32151 ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32152         ...
32153 }
32154 */
32155
32156 struct ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs
32157 {
32158         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32159         {
32160                 size_t get_index() const {return type;}
32161                 bool is_unknown() const { return type == 1; }
32162                 void clear() {type = 0;}
32163                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32164                 template<typename V>  bool decode(V& v)
32165                 {
32166                         clear();
32167                         if(!v(ref_nested())) return false;
32168                         { type = 1; return true;}
32169                         return false;
32170
32171                 }
32172                 template<typename V> bool encode(V& v) const
32173                 {
32174                         return v(ref_nested());
32175
32176                 }
32177                 protected:
32178                 template<typename V>  bool decode(size_t index, V& v)
32179                 {
32180                         clear();
32181                         switch(index)
32182                         {
32183                         case 1: type = 1; return v(ref_nested());
32184                         ref_nested().clear();
32185                         }
32186                         return false;
32187
32188                 }
32189                 template<typename V> bool encode(size_t index, V& v) const
32190                 {
32191                         if(index != type) {return false;} return v(ref_nested());
32192
32193                 }
32194                 private:
32195                 size_t type {0};
32196
32197         };
32198         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32199         {
32200                 size_t get_index() const {return type;}
32201                 bool is_unknown() const { return type == 1; }
32202                 void clear() {type = 0;}
32203                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32204                 template<typename V>  bool decode(V& v)
32205                 {
32206                         clear();
32207                         if(!v(ref_nested())) return false;
32208                         { type = 1; return true;}
32209                         return false;
32210
32211                 }
32212                 template<typename V> bool encode(V& v) const
32213                 {
32214                         return v(ref_nested());
32215
32216                 }
32217                 protected:
32218                 template<typename V>  bool decode(size_t index, V& v)
32219                 {
32220                         clear();
32221                         switch(index)
32222                         {
32223                         case 1: type = 1; return v(ref_nested());
32224                         ref_nested().clear();
32225                         }
32226                         return false;
32227
32228                 }
32229                 template<typename V> bool encode(size_t index, V& v) const
32230                 {
32231                         if(index != type) {return false;} return v(ref_nested());
32232
32233                 }
32234                 private:
32235                 size_t type {0};
32236
32237         };
32238         struct Extension_t : asn::typefield<true>
32239         {
32240                 ~Extension_t()  {clear();}
32241                 size_t get_index() const {return type;}
32242                 bool is_unknown() const { return type == 1; }
32243                 void clear()
32244                 {
32245                         type = 0; ref_nested().clear();
32246                 }
32247                 template<typename V> static inline void enumerate(V& v)
32248                 {
32249
32250                 }
32251                 protected:
32252                 template<typename V> bool decode(size_t index, V& v)
32253                 {
32254                         clear();
32255                         switch(index)
32256                         {
32257                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32258                         }
32259                         return false;
32260
32261                 }
32262                 template<typename V> bool encode(size_t index, V& v) const
32263                 {
32264                         if(index != type) return false;
32265                         return false;
32266
32267                 }
32268                 private:
32269                 size_t type {0};
32270
32271         };
32272         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32273         {
32274                 size_t get_index() const {return type;}
32275                 bool is_unknown() const { return type == 1; }
32276                 void clear() {type = 0;}
32277                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32278                 template<typename V>  bool decode(V& v)
32279                 {
32280                         clear();
32281                         if(!v(ref_nested())) return false;
32282                         { type = 1; return true;}
32283                         return false;
32284
32285                 }
32286                 template<typename V> bool encode(V& v) const
32287                 {
32288                         return v(ref_nested());
32289
32290                 }
32291                 protected:
32292                 template<typename V>  bool decode(size_t index, V& v)
32293                 {
32294                         clear();
32295                         switch(index)
32296                         {
32297                         case 1: type = 1; return v(ref_nested());
32298                         ref_nested().clear();
32299                         }
32300                         return false;
32301
32302                 }
32303                 template<typename V> bool encode(size_t index, V& v) const
32304                 {
32305                         if(index != type) {return false;} return v(ref_nested());
32306
32307                 }
32308                 private:
32309                 size_t type {0};
32310
32311         };
32312
32313 };
32314 /*
32315 ServedEUTRAcellsToModifyListENDCConfUpd ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
32316         old-ECGI                                                                ECGI,
32317         servedEUTRACellInfo                                     ServedCell-Information,
32318         nrNeighbourInfo                                         NRNeighbour-Information         OPTIONAL,
32319         iE-Extensions                                           ProtocolExtensionContainer { {ServedEUTRAcellsToModifyListENDCConfUpd-ExtIEs} } OPTIONAL,
32320         ...
32321 }
32322 */
32323
32324 struct ServedEUTRAcellsToModifyListENDCConfUpd_elm : asn::sequence<4, 0, true, 2>
32325 {
32326         static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd_elm";}
32327         using parent_t = asn::sequence<4, 0, true, 2>;
32328         struct old_ECGI_t : ECGI
32329         {
32330                 static constexpr const char* name() {return "old_ECGI_t";}
32331                 using parent_t = ECGI;
32332
32333         };
32334         old_ECGI_t& ref_old_ECGI() {return old_ECGI;}
32335         old_ECGI_t const& ref_old_ECGI() const {return old_ECGI;}
32336         struct servedEUTRACellInfo_t : ServedCell_Information
32337         {
32338                 static constexpr const char* name() {return "servedEUTRACellInfo_t";}
32339                 using parent_t = ServedCell_Information;
32340
32341         };
32342         servedEUTRACellInfo_t& ref_servedEUTRACellInfo() {return servedEUTRACellInfo;}
32343         servedEUTRACellInfo_t const& ref_servedEUTRACellInfo() const {return servedEUTRACellInfo;}
32344         struct nrNeighbourInfo_t : NRNeighbour_Information
32345         {
32346                 static constexpr const char* name() {return "nrNeighbourInfo_t";}
32347                 using parent_t = NRNeighbour_Information;
32348                 static constexpr bool optional = true;
32349
32350         };
32351         nrNeighbourInfo_t& set_nrNeighbourInfo() { nrNeighbourInfo.setpresent(true); return nrNeighbourInfo;}
32352         nrNeighbourInfo_t const* get_nrNeighbourInfo() const {return nrNeighbourInfo.is_valid() ? &nrNeighbourInfo : nullptr;}
32353         struct iE_Extensions_t : ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs>
32354         {
32355                 static constexpr const char* name() {return "iE_Extensions_t";}
32356                 using parent_t = ProtocolExtensionContainer<ServedEUTRAcellsToModifyListENDCConfUpd_ExtIEs>;
32357                 static constexpr bool optional = true;
32358
32359         };
32360         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32361         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32362         template<typename V> void decode(V& v)
32363         {
32364                 v(old_ECGI);
32365                 v(servedEUTRACellInfo);
32366                 v(nrNeighbourInfo);
32367                 v(iE_Extensions);
32368
32369         };
32370         template<typename V> void encode(V& v) const
32371         {
32372                 v(old_ECGI);
32373                 v(servedEUTRACellInfo);
32374                 v(nrNeighbourInfo);
32375                 v(iE_Extensions);
32376
32377         };
32378         void clear()
32379         {
32380                 old_ECGI.clear();
32381                 servedEUTRACellInfo.clear();
32382                 nrNeighbourInfo.clear();
32383                 iE_Extensions.clear();
32384
32385         };
32386         private:
32387         old_ECGI_t      old_ECGI;
32388         servedEUTRACellInfo_t   servedEUTRACellInfo;
32389         nrNeighbourInfo_t       nrNeighbourInfo;
32390         iE_Extensions_t iE_Extensions;
32391
32392 };
32393 struct ServedEUTRAcellsToModifyListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>
32394 {
32395         static constexpr const char* name() {return "ServedEUTRAcellsToModifyListENDCConfUpd";}
32396         using parent_t = asn::sequenceof<ServedEUTRAcellsToModifyListENDCConfUpd_elm>;
32397         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
32398
32399 };
32400 /*
32401 ServedEUTRAcellsToDeleteListENDCConfUpd ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
32402 */
32403
32404 struct ServedEUTRAcellsToDeleteListENDCConfUpd_elm : ECGI
32405 {
32406         static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd_elm";}
32407         using parent_t = ECGI;
32408
32409 };
32410 struct ServedEUTRAcellsToDeleteListENDCConfUpd : asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>
32411 {
32412         static constexpr const char* name() {return "ServedEUTRAcellsToDeleteListENDCConfUpd";}
32413         using parent_t = asn::sequenceof<ServedEUTRAcellsToDeleteListENDCConfUpd_elm>;
32414         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
32415
32416 };
32417 /*
32418 ENB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
32419         { ID id-CellAssistanceInformation                               CRITICALITY reject      TYPE CellAssistanceInformation                                                  PRESENCE optional }|
32420         { ID id-ServedEUTRAcellsENDCX2ManagementList            CRITICALITY reject      TYPE ServedEUTRAcellsENDCX2ManagementList                       PRESENCE optional }|
32421         { ID id-ServedEUTRAcellsToModifyListENDCConfUpd CRITICALITY reject      TYPE ServedEUTRAcellsToModifyListENDCConfUpd            PRESENCE optional }|
32422         { ID id-ServedEUTRAcellsToDeleteListENDCConfUpd CRITICALITY reject      TYPE ServedEUTRAcellsToDeleteListENDCConfUpd            PRESENCE optional },
32423         ...
32424 }
32425 */
32426
32427 struct ENB_ENDCConfigUpdateIEs
32428 {
32429         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32430         {
32431                 size_t get_index() const {return type;}
32432                 bool is_unknown() const { return type == 5; }
32433                 void clear() {type = 0;}
32434                 void select_id_CellAssistanceInformation() { set(id_CellAssistanceInformation); type=1;}
32435                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
32436                 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(id_ServedEUTRAcellsToModifyListENDCConfUpd); type=3;}
32437                 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(id_ServedEUTRAcellsToDeleteListENDCConfUpd); type=4;}
32438                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32439                 template<typename V>  bool decode(V& v)
32440                 {
32441                         clear();
32442                         if(!v(ref_nested())) return false;
32443                         if(equal(id_CellAssistanceInformation)) { type = 1; return true; }
32444                         else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
32445                         else if(equal(id_ServedEUTRAcellsToModifyListENDCConfUpd)) { type = 3; return true; }
32446                         else if(equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd)) { type = 4; return true; }
32447                         else { type = 5; return true;}
32448                         return false;
32449
32450                 }
32451                 template<typename V> bool encode(V& v) const
32452                 {
32453                         return v(ref_nested());
32454
32455                 }
32456                 protected:
32457                 template<typename V>  bool decode(size_t index, V& v)
32458                 {
32459                         clear();
32460                         switch(index)
32461                         {
32462                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CellAssistanceInformation);} return false;
32463                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
32464                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToModifyListENDCConfUpd);} return false;
32465                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsToDeleteListENDCConfUpd);} return false;
32466                         case 5: type = 5; return v(ref_nested());
32467                         ref_nested().clear();
32468                         }
32469                         return false;
32470
32471                 }
32472                 template<typename V> bool encode(size_t index, V& v) const
32473                 {
32474                         if(index != type) {return false;} return v(ref_nested());
32475
32476                 }
32477                 private:
32478                 size_t type {0};
32479
32480         };
32481         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32482         {
32483                 size_t get_index() const {return type;}
32484                 bool is_unknown() const { return type == 5; }
32485                 void clear() {type = 0;}
32486                 void select_id_CellAssistanceInformation() { set(reject); type=1;}
32487                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
32488                 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(reject); type=3;}
32489                 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(reject); type=4;}
32490                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32491                 template<typename V>  bool decode(V& v)
32492                 {
32493                         clear();
32494                         if(!v(ref_nested())) return false;
32495                         if(equal(reject)) { type = 1; return true; }
32496                         else if(equal(reject)) { type = 2; return true; }
32497                         else if(equal(reject)) { type = 3; return true; }
32498                         else if(equal(reject)) { type = 4; return true; }
32499                         else { type = 5; return true;}
32500                         return false;
32501
32502                 }
32503                 template<typename V> bool encode(V& v) const
32504                 {
32505                         return v(ref_nested());
32506
32507                 }
32508                 protected:
32509                 template<typename V>  bool decode(size_t index, V& v)
32510                 {
32511                         clear();
32512                         switch(index)
32513                         {
32514                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32515                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
32516                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
32517                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
32518                         case 5: type = 5; return v(ref_nested());
32519                         ref_nested().clear();
32520                         }
32521                         return false;
32522
32523                 }
32524                 template<typename V> bool encode(size_t index, V& v) const
32525                 {
32526                         if(index != type) {return false;} return v(ref_nested());
32527
32528                 }
32529                 private:
32530                 size_t type {0};
32531
32532         };
32533         struct Value_t : asn::typefield<true>
32534         {
32535                 ~Value_t()      {clear();}
32536                 size_t get_index() const {return type;}
32537                 CellAssistanceInformation& select_id_CellAssistanceInformation() { return set<CellAssistanceInformation>(1); }
32538                 CellAssistanceInformation const* get_id_CellAssistanceInformation() const { return get<CellAssistanceInformation>(1); }
32539                 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
32540                 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
32541                 ServedEUTRAcellsToModifyListENDCConfUpd& select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { return set<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
32542                 ServedEUTRAcellsToModifyListENDCConfUpd const* get_id_ServedEUTRAcellsToModifyListENDCConfUpd() const { return get<ServedEUTRAcellsToModifyListENDCConfUpd>(3); }
32543                 ServedEUTRAcellsToDeleteListENDCConfUpd& select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { return set<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
32544                 ServedEUTRAcellsToDeleteListENDCConfUpd const* get_id_ServedEUTRAcellsToDeleteListENDCConfUpd() const { return get<ServedEUTRAcellsToDeleteListENDCConfUpd>(4); }
32545                 bool is_unknown() const { return type == 5; }
32546                 void clear()
32547                 {
32548                         switch(type)
32549                         {
32550                         case 1: var.destroy<CellAssistanceInformation>(); break;
32551                         case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
32552                         case 3: var.destroy<ServedEUTRAcellsToModifyListENDCConfUpd>(); break;
32553                         case 4: var.destroy<ServedEUTRAcellsToDeleteListENDCConfUpd>(); break;
32554                         }
32555                         type = 0; ref_nested().clear();
32556                 }
32557                 template<typename V> static inline void enumerate(V& v)
32558                 {
32559                         v.template operator()<CellAssistanceInformation>(1);
32560                         v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
32561                         v.template operator()<ServedEUTRAcellsToModifyListENDCConfUpd>(3);
32562                         v.template operator()<ServedEUTRAcellsToDeleteListENDCConfUpd>(4);
32563
32564                 }
32565                 protected:
32566                 template<typename V> bool decode(size_t index, V& v)
32567                 {
32568                         clear();
32569                         switch(index)
32570                         {
32571                         case 1: v(select_id_CellAssistanceInformation()); return true;
32572                         case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
32573                         case 3: v(select_id_ServedEUTRAcellsToModifyListENDCConfUpd()); return true;
32574                         case 4: v(select_id_ServedEUTRAcellsToDeleteListENDCConfUpd()); return true;
32575                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
32576                         }
32577                         return false;
32578
32579                 }
32580                 template<typename V> bool encode(size_t index, V& v) const
32581                 {
32582                         if(index != type) return false;
32583                         switch(type)
32584                         {
32585                         case 1: v(var.as<CellAssistanceInformation>()); return true;
32586                         case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
32587                         case 3: v(var.as<ServedEUTRAcellsToModifyListENDCConfUpd>()); return true;
32588                         case 4: v(var.as<ServedEUTRAcellsToDeleteListENDCConfUpd>()); return true;
32589                         }
32590                         return false;
32591
32592                 }
32593                 private:
32594                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32595                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32596                 union union_type
32597                 {
32598                         char dummy1[sizeof(CellAssistanceInformation)];
32599                         char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
32600                         char dummy3[sizeof(ServedEUTRAcellsToDeleteListENDCConfUpd)];
32601                         char dummy4[sizeof(ServedEUTRAcellsToModifyListENDCConfUpd)];
32602
32603                 };
32604                 asn::variant<sizeof(union_type)> var;
32605                 size_t type {0};
32606
32607         };
32608         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
32609         {
32610                 size_t get_index() const {return type;}
32611                 bool is_unknown() const { return type == 5; }
32612                 void clear() {type = 0;}
32613                 void select_id_CellAssistanceInformation() { set(optional); type=1;}
32614                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(optional); type=2;}
32615                 void select_id_ServedEUTRAcellsToModifyListENDCConfUpd() { set(optional); type=3;}
32616                 void select_id_ServedEUTRAcellsToDeleteListENDCConfUpd() { set(optional); type=4;}
32617                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
32618                 template<typename V>  bool decode(V& v)
32619                 {
32620                         clear();
32621                         if(!v(ref_nested())) return false;
32622                         if(equal(optional)) { type = 1; return true; }
32623                         else if(equal(optional)) { type = 2; return true; }
32624                         else if(equal(optional)) { type = 3; return true; }
32625                         else if(equal(optional)) { type = 4; return true; }
32626                         else { type = 5; return true;}
32627                         return false;
32628
32629                 }
32630                 template<typename V> bool encode(V& v) const
32631                 {
32632                         return v(ref_nested());
32633
32634                 }
32635                 protected:
32636                 template<typename V>  bool decode(size_t index, V& v)
32637                 {
32638                         clear();
32639                         switch(index)
32640                         {
32641                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
32642                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
32643                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
32644                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
32645                         case 5: type = 5; return v(ref_nested());
32646                         ref_nested().clear();
32647                         }
32648                         return false;
32649
32650                 }
32651                 template<typename V> bool encode(size_t index, V& v) const
32652                 {
32653                         if(index != type) {return false;} return v(ref_nested());
32654
32655                 }
32656                 private:
32657                 size_t type {0};
32658
32659         };
32660
32661 };
32662 /*
32663 ENB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
32664         { ID id-GlobalENB-ID                                                            CRITICALITY reject      TYPE GlobalENB-ID                                                                               PRESENCE mandatory},
32665         ...
32666 }
32667 */
32668
32669 struct ENB_ENDCX2RemovalReqAckIEs
32670 {
32671         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32672         {
32673                 size_t get_index() const {return type;}
32674                 bool is_unknown() const { return type == 2; }
32675                 void clear() {type = 0;}
32676                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
32677                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32678                 template<typename V>  bool decode(V& v)
32679                 {
32680                         clear();
32681                         if(!v(ref_nested())) return false;
32682                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
32683                         else { type = 2; return true;}
32684                         return false;
32685
32686                 }
32687                 template<typename V> bool encode(V& v) const
32688                 {
32689                         return v(ref_nested());
32690
32691                 }
32692                 protected:
32693                 template<typename V>  bool decode(size_t index, V& v)
32694                 {
32695                         clear();
32696                         switch(index)
32697                         {
32698                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
32699                         case 2: type = 2; return v(ref_nested());
32700                         ref_nested().clear();
32701                         }
32702                         return false;
32703
32704                 }
32705                 template<typename V> bool encode(size_t index, V& v) const
32706                 {
32707                         if(index != type) {return false;} return v(ref_nested());
32708
32709                 }
32710                 private:
32711                 size_t type {0};
32712
32713         };
32714         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32715         {
32716                 size_t get_index() const {return type;}
32717                 bool is_unknown() const { return type == 2; }
32718                 void clear() {type = 0;}
32719                 void select_id_GlobalENB_ID() { set(reject); type=1;}
32720                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32721                 template<typename V>  bool decode(V& v)
32722                 {
32723                         clear();
32724                         if(!v(ref_nested())) return false;
32725                         if(equal(reject)) { type = 1; return true; }
32726                         else { type = 2; return true;}
32727                         return false;
32728
32729                 }
32730                 template<typename V> bool encode(V& v) const
32731                 {
32732                         return v(ref_nested());
32733
32734                 }
32735                 protected:
32736                 template<typename V>  bool decode(size_t index, V& v)
32737                 {
32738                         clear();
32739                         switch(index)
32740                         {
32741                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32742                         case 2: type = 2; return v(ref_nested());
32743                         ref_nested().clear();
32744                         }
32745                         return false;
32746
32747                 }
32748                 template<typename V> bool encode(size_t index, V& v) const
32749                 {
32750                         if(index != type) {return false;} return v(ref_nested());
32751
32752                 }
32753                 private:
32754                 size_t type {0};
32755
32756         };
32757         struct Value_t : asn::typefield<true>
32758         {
32759                 ~Value_t()      {clear();}
32760                 size_t get_index() const {return type;}
32761                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
32762                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
32763                 bool is_unknown() const { return type == 2; }
32764                 void clear()
32765                 {
32766                         switch(type)
32767                         {
32768                         case 1: var.destroy<GlobalENB_ID>(); break;
32769                         }
32770                         type = 0; ref_nested().clear();
32771                 }
32772                 template<typename V> static inline void enumerate(V& v)
32773                 {
32774                         v.template operator()<GlobalENB_ID>(1);
32775
32776                 }
32777                 protected:
32778                 template<typename V> bool decode(size_t index, V& v)
32779                 {
32780                         clear();
32781                         switch(index)
32782                         {
32783                         case 1: v(select_id_GlobalENB_ID()); return true;
32784                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
32785                         }
32786                         return false;
32787
32788                 }
32789                 template<typename V> bool encode(size_t index, V& v) const
32790                 {
32791                         if(index != type) return false;
32792                         switch(type)
32793                         {
32794                         case 1: v(var.as<GlobalENB_ID>()); return true;
32795                         }
32796                         return false;
32797
32798                 }
32799                 private:
32800                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32801                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32802                 union union_type
32803                 {
32804                         char dummy1[sizeof(GlobalENB_ID)];
32805
32806                 };
32807                 asn::variant<sizeof(union_type)> var;
32808                 size_t type {0};
32809
32810         };
32811         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
32812         {
32813                 size_t get_index() const {return type;}
32814                 bool is_unknown() const { return type == 2; }
32815                 void clear() {type = 0;}
32816                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
32817                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
32818                 template<typename V>  bool decode(V& v)
32819                 {
32820                         clear();
32821                         if(!v(ref_nested())) return false;
32822                         if(equal(mandatory)) { type = 1; return true; }
32823                         else { type = 2; return true;}
32824                         return false;
32825
32826                 }
32827                 template<typename V> bool encode(V& v) const
32828                 {
32829                         return v(ref_nested());
32830
32831                 }
32832                 protected:
32833                 template<typename V>  bool decode(size_t index, V& v)
32834                 {
32835                         clear();
32836                         switch(index)
32837                         {
32838                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
32839                         case 2: type = 2; return v(ref_nested());
32840                         ref_nested().clear();
32841                         }
32842                         return false;
32843
32844                 }
32845                 template<typename V> bool encode(size_t index, V& v) const
32846                 {
32847                         if(index != type) {return false;} return v(ref_nested());
32848
32849                 }
32850                 private:
32851                 size_t type {0};
32852
32853         };
32854
32855 };
32856 /*
32857 ENB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
32858         { ID id-GlobalENB-ID                                                            CRITICALITY reject      TYPE GlobalENB-ID                                                                               PRESENCE mandatory},
32859         ...
32860 }
32861 */
32862
32863 struct ENB_ENDCX2RemovalReqIEs
32864 {
32865         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
32866         {
32867                 size_t get_index() const {return type;}
32868                 bool is_unknown() const { return type == 2; }
32869                 void clear() {type = 0;}
32870                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
32871                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
32872                 template<typename V>  bool decode(V& v)
32873                 {
32874                         clear();
32875                         if(!v(ref_nested())) return false;
32876                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
32877                         else { type = 2; return true;}
32878                         return false;
32879
32880                 }
32881                 template<typename V> bool encode(V& v) const
32882                 {
32883                         return v(ref_nested());
32884
32885                 }
32886                 protected:
32887                 template<typename V>  bool decode(size_t index, V& v)
32888                 {
32889                         clear();
32890                         switch(index)
32891                         {
32892                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
32893                         case 2: type = 2; return v(ref_nested());
32894                         ref_nested().clear();
32895                         }
32896                         return false;
32897
32898                 }
32899                 template<typename V> bool encode(size_t index, V& v) const
32900                 {
32901                         if(index != type) {return false;} return v(ref_nested());
32902
32903                 }
32904                 private:
32905                 size_t type {0};
32906
32907         };
32908         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
32909         {
32910                 size_t get_index() const {return type;}
32911                 bool is_unknown() const { return type == 2; }
32912                 void clear() {type = 0;}
32913                 void select_id_GlobalENB_ID() { set(reject); type=1;}
32914                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
32915                 template<typename V>  bool decode(V& v)
32916                 {
32917                         clear();
32918                         if(!v(ref_nested())) return false;
32919                         if(equal(reject)) { type = 1; return true; }
32920                         else { type = 2; return true;}
32921                         return false;
32922
32923                 }
32924                 template<typename V> bool encode(V& v) const
32925                 {
32926                         return v(ref_nested());
32927
32928                 }
32929                 protected:
32930                 template<typename V>  bool decode(size_t index, V& v)
32931                 {
32932                         clear();
32933                         switch(index)
32934                         {
32935                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
32936                         case 2: type = 2; return v(ref_nested());
32937                         ref_nested().clear();
32938                         }
32939                         return false;
32940
32941                 }
32942                 template<typename V> bool encode(size_t index, V& v) const
32943                 {
32944                         if(index != type) {return false;} return v(ref_nested());
32945
32946                 }
32947                 private:
32948                 size_t type {0};
32949
32950         };
32951         struct Value_t : asn::typefield<true>
32952         {
32953                 ~Value_t()      {clear();}
32954                 size_t get_index() const {return type;}
32955                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
32956                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
32957                 bool is_unknown() const { return type == 2; }
32958                 void clear()
32959                 {
32960                         switch(type)
32961                         {
32962                         case 1: var.destroy<GlobalENB_ID>(); break;
32963                         }
32964                         type = 0; ref_nested().clear();
32965                 }
32966                 template<typename V> static inline void enumerate(V& v)
32967                 {
32968                         v.template operator()<GlobalENB_ID>(1);
32969
32970                 }
32971                 protected:
32972                 template<typename V> bool decode(size_t index, V& v)
32973                 {
32974                         clear();
32975                         switch(index)
32976                         {
32977                         case 1: v(select_id_GlobalENB_ID()); return true;
32978                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
32979                         }
32980                         return false;
32981
32982                 }
32983                 template<typename V> bool encode(size_t index, V& v) const
32984                 {
32985                         if(index != type) return false;
32986                         switch(type)
32987                         {
32988                         case 1: v(var.as<GlobalENB_ID>()); return true;
32989                         }
32990                         return false;
32991
32992                 }
32993                 private:
32994                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32995                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32996                 union union_type
32997                 {
32998                         char dummy1[sizeof(GlobalENB_ID)];
32999
33000                 };
33001                 asn::variant<sizeof(union_type)> var;
33002                 size_t type {0};
33003
33004         };
33005         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33006         {
33007                 size_t get_index() const {return type;}
33008                 bool is_unknown() const { return type == 2; }
33009                 void clear() {type = 0;}
33010                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33011                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33012                 template<typename V>  bool decode(V& v)
33013                 {
33014                         clear();
33015                         if(!v(ref_nested())) return false;
33016                         if(equal(mandatory)) { type = 1; return true; }
33017                         else { type = 2; return true;}
33018                         return false;
33019
33020                 }
33021                 template<typename V> bool encode(V& v) const
33022                 {
33023                         return v(ref_nested());
33024
33025                 }
33026                 protected:
33027                 template<typename V>  bool decode(size_t index, V& v)
33028                 {
33029                         clear();
33030                         switch(index)
33031                         {
33032                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33033                         case 2: type = 2; return v(ref_nested());
33034                         ref_nested().clear();
33035                         }
33036                         return false;
33037
33038                 }
33039                 template<typename V> bool encode(size_t index, V& v) const
33040                 {
33041                         if(index != type) {return false;} return v(ref_nested());
33042
33043                 }
33044                 private:
33045                 size_t type {0};
33046
33047         };
33048
33049 };
33050 /*
33051 ENB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
33052         { ID id-GlobalENB-ID                                                            CRITICALITY reject      TYPE GlobalENB-ID                                                                               PRESENCE mandatory}|
33053         { ID id-ServedEUTRAcellsENDCX2ManagementList            CRITICALITY reject      TYPE ServedEUTRAcellsENDCX2ManagementList               PRESENCE mandatory},
33054         ...
33055 }
33056 */
33057
33058 struct ENB_ENDCX2SetupReqAckIEs
33059 {
33060         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33061         {
33062                 size_t get_index() const {return type;}
33063                 bool is_unknown() const { return type == 3; }
33064                 void clear() {type = 0;}
33065                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
33066                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
33067                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33068                 template<typename V>  bool decode(V& v)
33069                 {
33070                         clear();
33071                         if(!v(ref_nested())) return false;
33072                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
33073                         else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
33074                         else { type = 3; return true;}
33075                         return false;
33076
33077                 }
33078                 template<typename V> bool encode(V& v) const
33079                 {
33080                         return v(ref_nested());
33081
33082                 }
33083                 protected:
33084                 template<typename V>  bool decode(size_t index, V& v)
33085                 {
33086                         clear();
33087                         switch(index)
33088                         {
33089                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
33090                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
33091                         case 3: type = 3; return v(ref_nested());
33092                         ref_nested().clear();
33093                         }
33094                         return false;
33095
33096                 }
33097                 template<typename V> bool encode(size_t index, V& v) const
33098                 {
33099                         if(index != type) {return false;} return v(ref_nested());
33100
33101                 }
33102                 private:
33103                 size_t type {0};
33104
33105         };
33106         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33107         {
33108                 size_t get_index() const {return type;}
33109                 bool is_unknown() const { return type == 3; }
33110                 void clear() {type = 0;}
33111                 void select_id_GlobalENB_ID() { set(reject); type=1;}
33112                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
33113                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33114                 template<typename V>  bool decode(V& v)
33115                 {
33116                         clear();
33117                         if(!v(ref_nested())) return false;
33118                         if(equal(reject)) { type = 1; return true; }
33119                         else if(equal(reject)) { type = 2; return true; }
33120                         else { type = 3; return true;}
33121                         return false;
33122
33123                 }
33124                 template<typename V> bool encode(V& v) const
33125                 {
33126                         return v(ref_nested());
33127
33128                 }
33129                 protected:
33130                 template<typename V>  bool decode(size_t index, V& v)
33131                 {
33132                         clear();
33133                         switch(index)
33134                         {
33135                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33136                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33137                         case 3: type = 3; return v(ref_nested());
33138                         ref_nested().clear();
33139                         }
33140                         return false;
33141
33142                 }
33143                 template<typename V> bool encode(size_t index, V& v) const
33144                 {
33145                         if(index != type) {return false;} return v(ref_nested());
33146
33147                 }
33148                 private:
33149                 size_t type {0};
33150
33151         };
33152         struct Value_t : asn::typefield<true>
33153         {
33154                 ~Value_t()      {clear();}
33155                 size_t get_index() const {return type;}
33156                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
33157                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
33158                 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
33159                 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
33160                 bool is_unknown() const { return type == 3; }
33161                 void clear()
33162                 {
33163                         switch(type)
33164                         {
33165                         case 1: var.destroy<GlobalENB_ID>(); break;
33166                         case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
33167                         }
33168                         type = 0; ref_nested().clear();
33169                 }
33170                 template<typename V> static inline void enumerate(V& v)
33171                 {
33172                         v.template operator()<GlobalENB_ID>(1);
33173                         v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
33174
33175                 }
33176                 protected:
33177                 template<typename V> bool decode(size_t index, V& v)
33178                 {
33179                         clear();
33180                         switch(index)
33181                         {
33182                         case 1: v(select_id_GlobalENB_ID()); return true;
33183                         case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
33184                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33185                         }
33186                         return false;
33187
33188                 }
33189                 template<typename V> bool encode(size_t index, V& v) const
33190                 {
33191                         if(index != type) return false;
33192                         switch(type)
33193                         {
33194                         case 1: v(var.as<GlobalENB_ID>()); return true;
33195                         case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
33196                         }
33197                         return false;
33198
33199                 }
33200                 private:
33201                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33202                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33203                 union union_type
33204                 {
33205                         char dummy1[sizeof(GlobalENB_ID)];
33206                         char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
33207
33208                 };
33209                 asn::variant<sizeof(union_type)> var;
33210                 size_t type {0};
33211
33212         };
33213         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33214         {
33215                 size_t get_index() const {return type;}
33216                 bool is_unknown() const { return type == 3; }
33217                 void clear() {type = 0;}
33218                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33219                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
33220                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33221                 template<typename V>  bool decode(V& v)
33222                 {
33223                         clear();
33224                         if(!v(ref_nested())) return false;
33225                         if(equal(mandatory)) { type = 1; return true; }
33226                         else if(equal(mandatory)) { type = 2; return true; }
33227                         else { type = 3; return true;}
33228                         return false;
33229
33230                 }
33231                 template<typename V> bool encode(V& v) const
33232                 {
33233                         return v(ref_nested());
33234
33235                 }
33236                 protected:
33237                 template<typename V>  bool decode(size_t index, V& v)
33238                 {
33239                         clear();
33240                         switch(index)
33241                         {
33242                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33243                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33244                         case 3: type = 3; return v(ref_nested());
33245                         ref_nested().clear();
33246                         }
33247                         return false;
33248
33249                 }
33250                 template<typename V> bool encode(size_t index, V& v) const
33251                 {
33252                         if(index != type) {return false;} return v(ref_nested());
33253
33254                 }
33255                 private:
33256                 size_t type {0};
33257
33258         };
33259
33260 };
33261 /*
33262 ENB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
33263         { ID id-GlobalENB-ID                                                            CRITICALITY reject      TYPE GlobalENB-ID                                                                               PRESENCE mandatory}|
33264         { ID id-ServedEUTRAcellsENDCX2ManagementList            CRITICALITY reject      TYPE ServedEUTRAcellsENDCX2ManagementList               PRESENCE mandatory},
33265         ...
33266 }
33267 */
33268
33269 struct ENB_ENDCX2SetupReqIEs
33270 {
33271         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33272         {
33273                 size_t get_index() const {return type;}
33274                 bool is_unknown() const { return type == 3; }
33275                 void clear() {type = 0;}
33276                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
33277                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(id_ServedEUTRAcellsENDCX2ManagementList); type=2;}
33278                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33279                 template<typename V>  bool decode(V& v)
33280                 {
33281                         clear();
33282                         if(!v(ref_nested())) return false;
33283                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
33284                         else if(equal(id_ServedEUTRAcellsENDCX2ManagementList)) { type = 2; return true; }
33285                         else { type = 3; return true;}
33286                         return false;
33287
33288                 }
33289                 template<typename V> bool encode(V& v) const
33290                 {
33291                         return v(ref_nested());
33292
33293                 }
33294                 protected:
33295                 template<typename V>  bool decode(size_t index, V& v)
33296                 {
33297                         clear();
33298                         switch(index)
33299                         {
33300                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
33301                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedEUTRAcellsENDCX2ManagementList);} return false;
33302                         case 3: type = 3; return v(ref_nested());
33303                         ref_nested().clear();
33304                         }
33305                         return false;
33306
33307                 }
33308                 template<typename V> bool encode(size_t index, V& v) const
33309                 {
33310                         if(index != type) {return false;} return v(ref_nested());
33311
33312                 }
33313                 private:
33314                 size_t type {0};
33315
33316         };
33317         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33318         {
33319                 size_t get_index() const {return type;}
33320                 bool is_unknown() const { return type == 3; }
33321                 void clear() {type = 0;}
33322                 void select_id_GlobalENB_ID() { set(reject); type=1;}
33323                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(reject); type=2;}
33324                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33325                 template<typename V>  bool decode(V& v)
33326                 {
33327                         clear();
33328                         if(!v(ref_nested())) return false;
33329                         if(equal(reject)) { type = 1; return true; }
33330                         else if(equal(reject)) { type = 2; return true; }
33331                         else { type = 3; return true;}
33332                         return false;
33333
33334                 }
33335                 template<typename V> bool encode(V& v) const
33336                 {
33337                         return v(ref_nested());
33338
33339                 }
33340                 protected:
33341                 template<typename V>  bool decode(size_t index, V& v)
33342                 {
33343                         clear();
33344                         switch(index)
33345                         {
33346                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33347                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33348                         case 3: type = 3; return v(ref_nested());
33349                         ref_nested().clear();
33350                         }
33351                         return false;
33352
33353                 }
33354                 template<typename V> bool encode(size_t index, V& v) const
33355                 {
33356                         if(index != type) {return false;} return v(ref_nested());
33357
33358                 }
33359                 private:
33360                 size_t type {0};
33361
33362         };
33363         struct Value_t : asn::typefield<true>
33364         {
33365                 ~Value_t()      {clear();}
33366                 size_t get_index() const {return type;}
33367                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
33368                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
33369                 ServedEUTRAcellsENDCX2ManagementList& select_id_ServedEUTRAcellsENDCX2ManagementList() { return set<ServedEUTRAcellsENDCX2ManagementList>(2); }
33370                 ServedEUTRAcellsENDCX2ManagementList const* get_id_ServedEUTRAcellsENDCX2ManagementList() const { return get<ServedEUTRAcellsENDCX2ManagementList>(2); }
33371                 bool is_unknown() const { return type == 3; }
33372                 void clear()
33373                 {
33374                         switch(type)
33375                         {
33376                         case 1: var.destroy<GlobalENB_ID>(); break;
33377                         case 2: var.destroy<ServedEUTRAcellsENDCX2ManagementList>(); break;
33378                         }
33379                         type = 0; ref_nested().clear();
33380                 }
33381                 template<typename V> static inline void enumerate(V& v)
33382                 {
33383                         v.template operator()<GlobalENB_ID>(1);
33384                         v.template operator()<ServedEUTRAcellsENDCX2ManagementList>(2);
33385
33386                 }
33387                 protected:
33388                 template<typename V> bool decode(size_t index, V& v)
33389                 {
33390                         clear();
33391                         switch(index)
33392                         {
33393                         case 1: v(select_id_GlobalENB_ID()); return true;
33394                         case 2: v(select_id_ServedEUTRAcellsENDCX2ManagementList()); return true;
33395                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33396                         }
33397                         return false;
33398
33399                 }
33400                 template<typename V> bool encode(size_t index, V& v) const
33401                 {
33402                         if(index != type) return false;
33403                         switch(type)
33404                         {
33405                         case 1: v(var.as<GlobalENB_ID>()); return true;
33406                         case 2: v(var.as<ServedEUTRAcellsENDCX2ManagementList>()); return true;
33407                         }
33408                         return false;
33409
33410                 }
33411                 private:
33412                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33413                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33414                 union union_type
33415                 {
33416                         char dummy1[sizeof(GlobalENB_ID)];
33417                         char dummy2[sizeof(ServedEUTRAcellsENDCX2ManagementList)];
33418
33419                 };
33420                 asn::variant<sizeof(union_type)> var;
33421                 size_t type {0};
33422
33423         };
33424         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33425         {
33426                 size_t get_index() const {return type;}
33427                 bool is_unknown() const { return type == 3; }
33428                 void clear() {type = 0;}
33429                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
33430                 void select_id_ServedEUTRAcellsENDCX2ManagementList() { set(mandatory); type=2;}
33431                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33432                 template<typename V>  bool decode(V& v)
33433                 {
33434                         clear();
33435                         if(!v(ref_nested())) return false;
33436                         if(equal(mandatory)) { type = 1; return true; }
33437                         else if(equal(mandatory)) { type = 2; return true; }
33438                         else { type = 3; return true;}
33439                         return false;
33440
33441                 }
33442                 template<typename V> bool encode(V& v) const
33443                 {
33444                         return v(ref_nested());
33445
33446                 }
33447                 protected:
33448                 template<typename V>  bool decode(size_t index, V& v)
33449                 {
33450                         clear();
33451                         switch(index)
33452                         {
33453                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33454                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33455                         case 3: type = 3; return v(ref_nested());
33456                         ref_nested().clear();
33457                         }
33458                         return false;
33459
33460                 }
33461                 template<typename V> bool encode(size_t index, V& v) const
33462                 {
33463                         if(index != type) {return false;} return v(ref_nested());
33464
33465                 }
33466                 private:
33467                 size_t type {0};
33468
33469         };
33470
33471 };
33472 /*
33473 ListofEUTRACellsinEUTRACoordinationResp ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
33474 */
33475
33476 struct ListofEUTRACellsinEUTRACoordinationResp_elm : ECGI
33477 {
33478         static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp_elm";}
33479         using parent_t = ECGI;
33480
33481 };
33482 struct ListofEUTRACellsinEUTRACoordinationResp : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>
33483 {
33484         static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationResp";}
33485         using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationResp_elm>;
33486         using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
33487
33488 };
33489 /*
33490 ENB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
33491         { ID id-DataTrafficResourceIndication                           CRITICALITY reject      TYPE DataTrafficResourceIndication                              PRESENCE mandatory}|
33492         { ID id-SpectrumSharingGroupID                                          CRITICALITY reject      TYPE SpectrumSharingGroupID                                                     PRESENCE mandatory}|
33493         { ID id-ListofEUTRACellsinEUTRACoordinationResp         CRITICALITY reject      TYPE ListofEUTRACellsinEUTRACoordinationResp    PRESENCE mandatory},
33494         ...
33495 }
33496 */
33497
33498 struct ENB_EUTRA_NRCellResourceCoordinationReqAckIEs
33499 {
33500         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33501         {
33502                 size_t get_index() const {return type;}
33503                 bool is_unknown() const { return type == 4; }
33504                 void clear() {type = 0;}
33505                 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
33506                 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
33507                 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(id_ListofEUTRACellsinEUTRACoordinationResp); type=3;}
33508                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33509                 template<typename V>  bool decode(V& v)
33510                 {
33511                         clear();
33512                         if(!v(ref_nested())) return false;
33513                         if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
33514                         else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
33515                         else if(equal(id_ListofEUTRACellsinEUTRACoordinationResp)) { type = 3; return true; }
33516                         else { type = 4; return true;}
33517                         return false;
33518
33519                 }
33520                 template<typename V> bool encode(V& v) const
33521                 {
33522                         return v(ref_nested());
33523
33524                 }
33525                 protected:
33526                 template<typename V>  bool decode(size_t index, V& v)
33527                 {
33528                         clear();
33529                         switch(index)
33530                         {
33531                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
33532                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
33533                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationResp);} return false;
33534                         case 4: type = 4; return v(ref_nested());
33535                         ref_nested().clear();
33536                         }
33537                         return false;
33538
33539                 }
33540                 template<typename V> bool encode(size_t index, V& v) const
33541                 {
33542                         if(index != type) {return false;} return v(ref_nested());
33543
33544                 }
33545                 private:
33546                 size_t type {0};
33547
33548         };
33549         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33550         {
33551                 size_t get_index() const {return type;}
33552                 bool is_unknown() const { return type == 4; }
33553                 void clear() {type = 0;}
33554                 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
33555                 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
33556                 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(reject); type=3;}
33557                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33558                 template<typename V>  bool decode(V& v)
33559                 {
33560                         clear();
33561                         if(!v(ref_nested())) return false;
33562                         if(equal(reject)) { type = 1; return true; }
33563                         else if(equal(reject)) { type = 2; return true; }
33564                         else if(equal(reject)) { type = 3; return true; }
33565                         else { type = 4; return true;}
33566                         return false;
33567
33568                 }
33569                 template<typename V> bool encode(V& v) const
33570                 {
33571                         return v(ref_nested());
33572
33573                 }
33574                 protected:
33575                 template<typename V>  bool decode(size_t index, V& v)
33576                 {
33577                         clear();
33578                         switch(index)
33579                         {
33580                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33581                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33582                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
33583                         case 4: type = 4; return v(ref_nested());
33584                         ref_nested().clear();
33585                         }
33586                         return false;
33587
33588                 }
33589                 template<typename V> bool encode(size_t index, V& v) const
33590                 {
33591                         if(index != type) {return false;} return v(ref_nested());
33592
33593                 }
33594                 private:
33595                 size_t type {0};
33596
33597         };
33598         struct Value_t : asn::typefield<true>
33599         {
33600                 ~Value_t()      {clear();}
33601                 size_t get_index() const {return type;}
33602                 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
33603                 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
33604                 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
33605                 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
33606                 ListofEUTRACellsinEUTRACoordinationResp& select_id_ListofEUTRACellsinEUTRACoordinationResp() { return set<ListofEUTRACellsinEUTRACoordinationResp>(3); }
33607                 ListofEUTRACellsinEUTRACoordinationResp const* get_id_ListofEUTRACellsinEUTRACoordinationResp() const { return get<ListofEUTRACellsinEUTRACoordinationResp>(3); }
33608                 bool is_unknown() const { return type == 4; }
33609                 void clear()
33610                 {
33611                         switch(type)
33612                         {
33613                         case 1: var.destroy<DataTrafficResourceIndication>(); break;
33614                         case 2: var.destroy<SpectrumSharingGroupID>(); break;
33615                         case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationResp>(); break;
33616                         }
33617                         type = 0; ref_nested().clear();
33618                 }
33619                 template<typename V> static inline void enumerate(V& v)
33620                 {
33621                         v.template operator()<DataTrafficResourceIndication>(1);
33622                         v.template operator()<SpectrumSharingGroupID>(2);
33623                         v.template operator()<ListofEUTRACellsinEUTRACoordinationResp>(3);
33624
33625                 }
33626                 protected:
33627                 template<typename V> bool decode(size_t index, V& v)
33628                 {
33629                         clear();
33630                         switch(index)
33631                         {
33632                         case 1: v(select_id_DataTrafficResourceIndication()); return true;
33633                         case 2: v(select_id_SpectrumSharingGroupID()); return true;
33634                         case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationResp()); return true;
33635                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
33636                         }
33637                         return false;
33638
33639                 }
33640                 template<typename V> bool encode(size_t index, V& v) const
33641                 {
33642                         if(index != type) return false;
33643                         switch(type)
33644                         {
33645                         case 1: v(var.as<DataTrafficResourceIndication>()); return true;
33646                         case 2: v(var.as<SpectrumSharingGroupID>()); return true;
33647                         case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationResp>()); return true;
33648                         }
33649                         return false;
33650
33651                 }
33652                 private:
33653                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33654                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33655                 union union_type
33656                 {
33657                         char dummy1[sizeof(DataTrafficResourceIndication)];
33658                         char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationResp)];
33659                         char dummy3[sizeof(SpectrumSharingGroupID)];
33660
33661                 };
33662                 asn::variant<sizeof(union_type)> var;
33663                 size_t type {0};
33664
33665         };
33666         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33667         {
33668                 size_t get_index() const {return type;}
33669                 bool is_unknown() const { return type == 4; }
33670                 void clear() {type = 0;}
33671                 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
33672                 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
33673                 void select_id_ListofEUTRACellsinEUTRACoordinationResp() { set(mandatory); type=3;}
33674                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33675                 template<typename V>  bool decode(V& v)
33676                 {
33677                         clear();
33678                         if(!v(ref_nested())) return false;
33679                         if(equal(mandatory)) { type = 1; return true; }
33680                         else if(equal(mandatory)) { type = 2; return true; }
33681                         else if(equal(mandatory)) { type = 3; return true; }
33682                         else { type = 4; return true;}
33683                         return false;
33684
33685                 }
33686                 template<typename V> bool encode(V& v) const
33687                 {
33688                         return v(ref_nested());
33689
33690                 }
33691                 protected:
33692                 template<typename V>  bool decode(size_t index, V& v)
33693                 {
33694                         clear();
33695                         switch(index)
33696                         {
33697                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33698                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33699                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
33700                         case 4: type = 4; return v(ref_nested());
33701                         ref_nested().clear();
33702                         }
33703                         return false;
33704
33705                 }
33706                 template<typename V> bool encode(size_t index, V& v) const
33707                 {
33708                         if(index != type) {return false;} return v(ref_nested());
33709
33710                 }
33711                 private:
33712                 size_t type {0};
33713
33714         };
33715
33716 };
33717 /*
33718 ListofEUTRACellsinEUTRACoordinationReq ::= SEQUENCE (SIZE (0..maxCellineNB)) OF ECGI
33719 */
33720
33721 struct ListofEUTRACellsinEUTRACoordinationReq_elm : ECGI
33722 {
33723         static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq_elm";}
33724         using parent_t = ECGI;
33725
33726 };
33727 struct ListofEUTRACellsinEUTRACoordinationReq : asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>
33728 {
33729         static constexpr const char* name() {return "ListofEUTRACellsinEUTRACoordinationReq";}
33730         using parent_t = asn::sequenceof<ListofEUTRACellsinEUTRACoordinationReq_elm>;
33731         using constraint_t = asn::constraints<false,asn::span<0,  maxCellineNB >>;
33732
33733 };
33734 /*
33735 ENB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
33736         { ID id-DataTrafficResourceIndication                   CRITICALITY reject      TYPE DataTrafficResourceIndication                                      PRESENCE mandatory}|
33737         { ID id-SpectrumSharingGroupID                                  CRITICALITY reject      TYPE SpectrumSharingGroupID                                                     PRESENCE mandatory}|
33738         { ID id-ListofEUTRACellsinEUTRACoordinationReq  CRITICALITY reject      TYPE ListofEUTRACellsinEUTRACoordinationReq             PRESENCE mandatory},
33739         ...
33740 }
33741 */
33742
33743 struct ENB_EUTRA_NRCellResourceCoordinationReqIEs
33744 {
33745         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
33746         {
33747                 size_t get_index() const {return type;}
33748                 bool is_unknown() const { return type == 4; }
33749                 void clear() {type = 0;}
33750                 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
33751                 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
33752                 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(id_ListofEUTRACellsinEUTRACoordinationReq); type=3;}
33753                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
33754                 template<typename V>  bool decode(V& v)
33755                 {
33756                         clear();
33757                         if(!v(ref_nested())) return false;
33758                         if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
33759                         else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
33760                         else if(equal(id_ListofEUTRACellsinEUTRACoordinationReq)) { type = 3; return true; }
33761                         else { type = 4; return true;}
33762                         return false;
33763
33764                 }
33765                 template<typename V> bool encode(V& v) const
33766                 {
33767                         return v(ref_nested());
33768
33769                 }
33770                 protected:
33771                 template<typename V>  bool decode(size_t index, V& v)
33772                 {
33773                         clear();
33774                         switch(index)
33775                         {
33776                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
33777                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
33778                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinEUTRACoordinationReq);} return false;
33779                         case 4: type = 4; return v(ref_nested());
33780                         ref_nested().clear();
33781                         }
33782                         return false;
33783
33784                 }
33785                 template<typename V> bool encode(size_t index, V& v) const
33786                 {
33787                         if(index != type) {return false;} return v(ref_nested());
33788
33789                 }
33790                 private:
33791                 size_t type {0};
33792
33793         };
33794         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
33795         {
33796                 size_t get_index() const {return type;}
33797                 bool is_unknown() const { return type == 4; }
33798                 void clear() {type = 0;}
33799                 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
33800                 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
33801                 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(reject); type=3;}
33802                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
33803                 template<typename V>  bool decode(V& v)
33804                 {
33805                         clear();
33806                         if(!v(ref_nested())) return false;
33807                         if(equal(reject)) { type = 1; return true; }
33808                         else if(equal(reject)) { type = 2; return true; }
33809                         else if(equal(reject)) { type = 3; return true; }
33810                         else { type = 4; return true;}
33811                         return false;
33812
33813                 }
33814                 template<typename V> bool encode(V& v) const
33815                 {
33816                         return v(ref_nested());
33817
33818                 }
33819                 protected:
33820                 template<typename V>  bool decode(size_t index, V& v)
33821                 {
33822                         clear();
33823                         switch(index)
33824                         {
33825                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
33826                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
33827                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
33828                         case 4: type = 4; return v(ref_nested());
33829                         ref_nested().clear();
33830                         }
33831                         return false;
33832
33833                 }
33834                 template<typename V> bool encode(size_t index, V& v) const
33835                 {
33836                         if(index != type) {return false;} return v(ref_nested());
33837
33838                 }
33839                 private:
33840                 size_t type {0};
33841
33842         };
33843         struct Value_t : asn::typefield<true>
33844         {
33845                 ~Value_t()      {clear();}
33846                 size_t get_index() const {return type;}
33847                 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
33848                 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
33849                 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
33850                 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
33851                 ListofEUTRACellsinEUTRACoordinationReq& select_id_ListofEUTRACellsinEUTRACoordinationReq() { return set<ListofEUTRACellsinEUTRACoordinationReq>(3); }
33852                 ListofEUTRACellsinEUTRACoordinationReq const* get_id_ListofEUTRACellsinEUTRACoordinationReq() const { return get<ListofEUTRACellsinEUTRACoordinationReq>(3); }
33853                 bool is_unknown() const { return type == 4; }
33854                 void clear()
33855                 {
33856                         switch(type)
33857                         {
33858                         case 1: var.destroy<DataTrafficResourceIndication>(); break;
33859                         case 2: var.destroy<SpectrumSharingGroupID>(); break;
33860                         case 3: var.destroy<ListofEUTRACellsinEUTRACoordinationReq>(); break;
33861                         }
33862                         type = 0; ref_nested().clear();
33863                 }
33864                 template<typename V> static inline void enumerate(V& v)
33865                 {
33866                         v.template operator()<DataTrafficResourceIndication>(1);
33867                         v.template operator()<SpectrumSharingGroupID>(2);
33868                         v.template operator()<ListofEUTRACellsinEUTRACoordinationReq>(3);
33869
33870                 }
33871                 protected:
33872                 template<typename V> bool decode(size_t index, V& v)
33873                 {
33874                         clear();
33875                         switch(index)
33876                         {
33877                         case 1: v(select_id_DataTrafficResourceIndication()); return true;
33878                         case 2: v(select_id_SpectrumSharingGroupID()); return true;
33879                         case 3: v(select_id_ListofEUTRACellsinEUTRACoordinationReq()); return true;
33880                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
33881                         }
33882                         return false;
33883
33884                 }
33885                 template<typename V> bool encode(size_t index, V& v) const
33886                 {
33887                         if(index != type) return false;
33888                         switch(type)
33889                         {
33890                         case 1: v(var.as<DataTrafficResourceIndication>()); return true;
33891                         case 2: v(var.as<SpectrumSharingGroupID>()); return true;
33892                         case 3: v(var.as<ListofEUTRACellsinEUTRACoordinationReq>()); return true;
33893                         }
33894                         return false;
33895
33896                 }
33897                 private:
33898                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33899                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33900                 union union_type
33901                 {
33902                         char dummy1[sizeof(DataTrafficResourceIndication)];
33903                         char dummy2[sizeof(ListofEUTRACellsinEUTRACoordinationReq)];
33904                         char dummy3[sizeof(SpectrumSharingGroupID)];
33905
33906                 };
33907                 asn::variant<sizeof(union_type)> var;
33908                 size_t type {0};
33909
33910         };
33911         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
33912         {
33913                 size_t get_index() const {return type;}
33914                 bool is_unknown() const { return type == 4; }
33915                 void clear() {type = 0;}
33916                 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
33917                 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
33918                 void select_id_ListofEUTRACellsinEUTRACoordinationReq() { set(mandatory); type=3;}
33919                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
33920                 template<typename V>  bool decode(V& v)
33921                 {
33922                         clear();
33923                         if(!v(ref_nested())) return false;
33924                         if(equal(mandatory)) { type = 1; return true; }
33925                         else if(equal(mandatory)) { type = 2; return true; }
33926                         else if(equal(mandatory)) { type = 3; return true; }
33927                         else { type = 4; return true;}
33928                         return false;
33929
33930                 }
33931                 template<typename V> bool encode(V& v) const
33932                 {
33933                         return v(ref_nested());
33934
33935                 }
33936                 protected:
33937                 template<typename V>  bool decode(size_t index, V& v)
33938                 {
33939                         clear();
33940                         switch(index)
33941                         {
33942                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
33943                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
33944                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
33945                         case 4: type = 4; return v(ref_nested());
33946                         ref_nested().clear();
33947                         }
33948                         return false;
33949
33950                 }
33951                 template<typename V> bool encode(size_t index, V& v) const
33952                 {
33953                         if(index != type) {return false;} return v(ref_nested());
33954
33955                 }
33956                 private:
33957                 size_t type {0};
33958
33959         };
33960
33961 };
33962 /*
33963 ServedCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33964 { ID id-DeactivationIndication                  CRITICALITY ignore      EXTENSION DeactivationIndication                                PRESENCE optional },
33965         ...
33966 }
33967 */
33968
33969 struct ServedCellsToModify_Item_ExtIEs
33970 {
33971         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33972         {
33973                 size_t get_index() const {return type;}
33974                 bool is_unknown() const { return type == 2; }
33975                 void clear() {type = 0;}
33976                 void select_id_DeactivationIndication() { set(id_DeactivationIndication); type=1;}
33977                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33978                 template<typename V>  bool decode(V& v)
33979                 {
33980                         clear();
33981                         if(!v(ref_nested())) return false;
33982                         if(equal(id_DeactivationIndication)) { type = 1; return true; }
33983                         else { type = 2; return true;}
33984                         return false;
33985
33986                 }
33987                 template<typename V> bool encode(V& v) const
33988                 {
33989                         return v(ref_nested());
33990
33991                 }
33992                 protected:
33993                 template<typename V>  bool decode(size_t index, V& v)
33994                 {
33995                         clear();
33996                         switch(index)
33997                         {
33998                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DeactivationIndication);} return false;
33999                         case 2: type = 2; return v(ref_nested());
34000                         ref_nested().clear();
34001                         }
34002                         return false;
34003
34004                 }
34005                 template<typename V> bool encode(size_t index, V& v) const
34006                 {
34007                         if(index != type) {return false;} return v(ref_nested());
34008
34009                 }
34010                 private:
34011                 size_t type {0};
34012
34013         };
34014         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34015         {
34016                 size_t get_index() const {return type;}
34017                 bool is_unknown() const { return type == 2; }
34018                 void clear() {type = 0;}
34019                 void select_id_DeactivationIndication() { set(ignore); type=1;}
34020                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34021                 template<typename V>  bool decode(V& v)
34022                 {
34023                         clear();
34024                         if(!v(ref_nested())) return false;
34025                         if(equal(ignore)) { type = 1; return true; }
34026                         else { type = 2; return true;}
34027                         return false;
34028
34029                 }
34030                 template<typename V> bool encode(V& v) const
34031                 {
34032                         return v(ref_nested());
34033
34034                 }
34035                 protected:
34036                 template<typename V>  bool decode(size_t index, V& v)
34037                 {
34038                         clear();
34039                         switch(index)
34040                         {
34041                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34042                         case 2: type = 2; return v(ref_nested());
34043                         ref_nested().clear();
34044                         }
34045                         return false;
34046
34047                 }
34048                 template<typename V> bool encode(size_t index, V& v) const
34049                 {
34050                         if(index != type) {return false;} return v(ref_nested());
34051
34052                 }
34053                 private:
34054                 size_t type {0};
34055
34056         };
34057         struct Extension_t : asn::typefield<true>
34058         {
34059                 ~Extension_t()  {clear();}
34060                 size_t get_index() const {return type;}
34061                 DeactivationIndication& select_id_DeactivationIndication() { return set<DeactivationIndication>(1); }
34062                 DeactivationIndication const* get_id_DeactivationIndication() const { return get<DeactivationIndication>(1); }
34063                 bool is_unknown() const { return type == 2; }
34064                 void clear()
34065                 {
34066                         switch(type)
34067                         {
34068                         case 1: var.destroy<DeactivationIndication>(); break;
34069                         }
34070                         type = 0; ref_nested().clear();
34071                 }
34072                 template<typename V> static inline void enumerate(V& v)
34073                 {
34074                         v.template operator()<DeactivationIndication>(1);
34075
34076                 }
34077                 protected:
34078                 template<typename V> bool decode(size_t index, V& v)
34079                 {
34080                         clear();
34081                         switch(index)
34082                         {
34083                         case 1: v(select_id_DeactivationIndication()); return true;
34084                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
34085                         }
34086                         return false;
34087
34088                 }
34089                 template<typename V> bool encode(size_t index, V& v) const
34090                 {
34091                         if(index != type) return false;
34092                         switch(type)
34093                         {
34094                         case 1: v(var.as<DeactivationIndication>()); return true;
34095                         }
34096                         return false;
34097
34098                 }
34099                 private:
34100                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34101                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34102                 union union_type
34103                 {
34104                         char dummy1[sizeof(DeactivationIndication)];
34105
34106                 };
34107                 asn::variant<sizeof(union_type)> var;
34108                 size_t type {0};
34109
34110         };
34111         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34112         {
34113                 size_t get_index() const {return type;}
34114                 bool is_unknown() const { return type == 2; }
34115                 void clear() {type = 0;}
34116                 void select_id_DeactivationIndication() { set(optional); type=1;}
34117                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34118                 template<typename V>  bool decode(V& v)
34119                 {
34120                         clear();
34121                         if(!v(ref_nested())) return false;
34122                         if(equal(optional)) { type = 1; return true; }
34123                         else { type = 2; return true;}
34124                         return false;
34125
34126                 }
34127                 template<typename V> bool encode(V& v) const
34128                 {
34129                         return v(ref_nested());
34130
34131                 }
34132                 protected:
34133                 template<typename V>  bool decode(size_t index, V& v)
34134                 {
34135                         clear();
34136                         switch(index)
34137                         {
34138                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34139                         case 2: type = 2; return v(ref_nested());
34140                         ref_nested().clear();
34141                         }
34142                         return false;
34143
34144                 }
34145                 template<typename V> bool encode(size_t index, V& v) const
34146                 {
34147                         if(index != type) {return false;} return v(ref_nested());
34148
34149                 }
34150                 private:
34151                 size_t type {0};
34152
34153         };
34154
34155 };
34156 /*
34157 ServedCellsToModify-Item::= SEQUENCE {
34158         old-ecgi                                                ECGI,
34159         servedCellInfo                                  ServedCell-Information,
34160         neighbour-Info                                  Neighbour-Information                   OPTIONAL,
34161         iE-Extensions                                   ProtocolExtensionContainer { {ServedCellsToModify-Item-ExtIEs} } OPTIONAL,
34162         ...
34163 }
34164 */
34165
34166 struct ServedCellsToModify_Item : asn::sequence<4, 0, true, 2>
34167 {
34168         static constexpr const char* name() {return "ServedCellsToModify-Item";}
34169         using parent_t = asn::sequence<4, 0, true, 2>;
34170         struct old_ecgi_t : ECGI
34171         {
34172                 static constexpr const char* name() {return "old_ecgi_t";}
34173                 using parent_t = ECGI;
34174
34175         };
34176         old_ecgi_t& ref_old_ecgi() {return old_ecgi;}
34177         old_ecgi_t const& ref_old_ecgi() const {return old_ecgi;}
34178         struct servedCellInfo_t : ServedCell_Information
34179         {
34180                 static constexpr const char* name() {return "servedCellInfo_t";}
34181                 using parent_t = ServedCell_Information;
34182
34183         };
34184         servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
34185         servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
34186         struct neighbour_Info_t : Neighbour_Information
34187         {
34188                 static constexpr const char* name() {return "neighbour_Info_t";}
34189                 using parent_t = Neighbour_Information;
34190                 static constexpr bool optional = true;
34191
34192         };
34193         neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
34194         neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
34195         struct iE_Extensions_t : ProtocolExtensionContainer<ServedCellsToModify_Item_ExtIEs>
34196         {
34197                 static constexpr const char* name() {return "iE_Extensions_t";}
34198                 using parent_t = ProtocolExtensionContainer<ServedCellsToModify_Item_ExtIEs>;
34199                 static constexpr bool optional = true;
34200
34201         };
34202         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34203         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34204         template<typename V> void decode(V& v)
34205         {
34206                 v(old_ecgi);
34207                 v(servedCellInfo);
34208                 v(neighbour_Info);
34209                 v(iE_Extensions);
34210
34211         };
34212         template<typename V> void encode(V& v) const
34213         {
34214                 v(old_ecgi);
34215                 v(servedCellInfo);
34216                 v(neighbour_Info);
34217                 v(iE_Extensions);
34218
34219         };
34220         void clear()
34221         {
34222                 old_ecgi.clear();
34223                 servedCellInfo.clear();
34224                 neighbour_Info.clear();
34225                 iE_Extensions.clear();
34226
34227         };
34228         private:
34229         old_ecgi_t      old_ecgi;
34230         servedCellInfo_t        servedCellInfo;
34231         neighbour_Info_t        neighbour_Info;
34232         iE_Extensions_t iE_Extensions;
34233
34234 };
34235 /*
34236 ServedCellsToModify::= SEQUENCE (SIZE (1..maxCellineNB)) OF ServedCellsToModify-Item
34237 */
34238
34239 struct ServedCellsToModify_elm : ServedCellsToModify_Item
34240 {
34241         static constexpr const char* name() {return "ServedCellsToModify_elm";}
34242         using parent_t = ServedCellsToModify_Item;
34243
34244 };
34245 struct ServedCellsToModify : asn::sequenceof<ServedCellsToModify_elm>
34246 {
34247         static constexpr const char* name() {return "ServedCellsToModify";}
34248         using parent_t = asn::sequenceof<ServedCellsToModify_elm>;
34249         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
34250
34251 };
34252 /*
34253 Old-ECGIs::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
34254 */
34255
34256 struct Old_ECGIs_elm : ECGI
34257 {
34258         static constexpr const char* name() {return "Old_ECGIs_elm";}
34259         using parent_t = ECGI;
34260
34261 };
34262 struct Old_ECGIs : asn::sequenceof<Old_ECGIs_elm>
34263 {
34264         static constexpr const char* name() {return "Old-ECGIs";}
34265         using parent_t = asn::sequenceof<Old_ECGIs_elm>;
34266         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
34267
34268 };
34269 /*
34270 ENBConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
34271         { ID id-ServedCellsToAdd                        CRITICALITY reject      TYPE ServedCells                                        PRESENCE optional}|
34272         { ID id-ServedCellsToModify                     CRITICALITY reject      TYPE ServedCellsToModify                        PRESENCE optional}|
34273         { ID id-ServedCellsToDelete                     CRITICALITY reject      TYPE Old-ECGIs                                          PRESENCE optional}|
34274         { ID id-GUGroupIDToAddList                      CRITICALITY reject      TYPE GUGroupIDList                                      PRESENCE optional}|
34275         { ID id-GUGroupIDToDeleteList           CRITICALITY reject      TYPE GUGroupIDList                                      PRESENCE optional}|
34276         { ID id-CoverageModificationList        CRITICALITY reject      TYPE CoverageModificationList           PRESENCE optional},
34277         ...
34278 }
34279 */
34280
34281 struct ENBConfigurationUpdate_IEs
34282 {
34283         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34284         {
34285                 size_t get_index() const {return type;}
34286                 bool is_unknown() const { return type == 7; }
34287                 void clear() {type = 0;}
34288                 void select_id_ServedCellsToAdd() { set(id_ServedCellsToAdd); type=1;}
34289                 void select_id_ServedCellsToModify() { set(id_ServedCellsToModify); type=2;}
34290                 void select_id_ServedCellsToDelete() { set(id_ServedCellsToDelete); type=3;}
34291                 void select_id_GUGroupIDToAddList() { set(id_GUGroupIDToAddList); type=4;}
34292                 void select_id_GUGroupIDToDeleteList() { set(id_GUGroupIDToDeleteList); type=5;}
34293                 void select_id_CoverageModificationList() { set(id_CoverageModificationList); type=6;}
34294                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34295                 template<typename V>  bool decode(V& v)
34296                 {
34297                         clear();
34298                         if(!v(ref_nested())) return false;
34299                         if(equal(id_ServedCellsToAdd)) { type = 1; return true; }
34300                         else if(equal(id_ServedCellsToModify)) { type = 2; return true; }
34301                         else if(equal(id_ServedCellsToDelete)) { type = 3; return true; }
34302                         else if(equal(id_GUGroupIDToAddList)) { type = 4; return true; }
34303                         else if(equal(id_GUGroupIDToDeleteList)) { type = 5; return true; }
34304                         else if(equal(id_CoverageModificationList)) { type = 6; return true; }
34305                         else { type = 7; return true;}
34306                         return false;
34307
34308                 }
34309                 template<typename V> bool encode(V& v) const
34310                 {
34311                         return v(ref_nested());
34312
34313                 }
34314                 protected:
34315                 template<typename V>  bool decode(size_t index, V& v)
34316                 {
34317                         clear();
34318                         switch(index)
34319                         {
34320                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedCellsToAdd);} return false;
34321                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCellsToModify);} return false;
34322                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedCellsToDelete);} return false;
34323                         case 4: type = 4; if(v(ref_nested())) { return equal(id_GUGroupIDToAddList);} return false;
34324                         case 5: type = 5; if(v(ref_nested())) { return equal(id_GUGroupIDToDeleteList);} return false;
34325                         case 6: type = 6; if(v(ref_nested())) { return equal(id_CoverageModificationList);} return false;
34326                         case 7: type = 7; return v(ref_nested());
34327                         ref_nested().clear();
34328                         }
34329                         return false;
34330
34331                 }
34332                 template<typename V> bool encode(size_t index, V& v) const
34333                 {
34334                         if(index != type) {return false;} return v(ref_nested());
34335
34336                 }
34337                 private:
34338                 size_t type {0};
34339
34340         };
34341         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34342         {
34343                 size_t get_index() const {return type;}
34344                 bool is_unknown() const { return type == 7; }
34345                 void clear() {type = 0;}
34346                 void select_id_ServedCellsToAdd() { set(reject); type=1;}
34347                 void select_id_ServedCellsToModify() { set(reject); type=2;}
34348                 void select_id_ServedCellsToDelete() { set(reject); type=3;}
34349                 void select_id_GUGroupIDToAddList() { set(reject); type=4;}
34350                 void select_id_GUGroupIDToDeleteList() { set(reject); type=5;}
34351                 void select_id_CoverageModificationList() { set(reject); type=6;}
34352                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34353                 template<typename V>  bool decode(V& v)
34354                 {
34355                         clear();
34356                         if(!v(ref_nested())) return false;
34357                         if(equal(reject)) { type = 1; return true; }
34358                         else if(equal(reject)) { type = 2; return true; }
34359                         else if(equal(reject)) { type = 3; return true; }
34360                         else if(equal(reject)) { type = 4; return true; }
34361                         else if(equal(reject)) { type = 5; return true; }
34362                         else if(equal(reject)) { type = 6; return true; }
34363                         else { type = 7; return true;}
34364                         return false;
34365
34366                 }
34367                 template<typename V> bool encode(V& v) const
34368                 {
34369                         return v(ref_nested());
34370
34371                 }
34372                 protected:
34373                 template<typename V>  bool decode(size_t index, V& v)
34374                 {
34375                         clear();
34376                         switch(index)
34377                         {
34378                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
34379                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
34380                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
34381                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
34382                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
34383                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
34384                         case 7: type = 7; return v(ref_nested());
34385                         ref_nested().clear();
34386                         }
34387                         return false;
34388
34389                 }
34390                 template<typename V> bool encode(size_t index, V& v) const
34391                 {
34392                         if(index != type) {return false;} return v(ref_nested());
34393
34394                 }
34395                 private:
34396                 size_t type {0};
34397
34398         };
34399         struct Value_t : asn::typefield<true>
34400         {
34401                 ~Value_t()      {clear();}
34402                 size_t get_index() const {return type;}
34403                 ServedCells& select_id_ServedCellsToAdd() { return set<ServedCells>(1); }
34404                 ServedCells const* get_id_ServedCellsToAdd() const { return get<ServedCells>(1); }
34405                 ServedCellsToModify& select_id_ServedCellsToModify() { return set<ServedCellsToModify>(2); }
34406                 ServedCellsToModify const* get_id_ServedCellsToModify() const { return get<ServedCellsToModify>(2); }
34407                 Old_ECGIs& select_id_ServedCellsToDelete() { return set<Old_ECGIs>(3); }
34408                 Old_ECGIs const* get_id_ServedCellsToDelete() const { return get<Old_ECGIs>(3); }
34409                 GUGroupIDList& select_id_GUGroupIDToAddList() { return set<GUGroupIDList>(4); }
34410                 GUGroupIDList const* get_id_GUGroupIDToAddList() const { return get<GUGroupIDList>(4); }
34411                 GUGroupIDList& select_id_GUGroupIDToDeleteList() { return set<GUGroupIDList>(5); }
34412                 GUGroupIDList const* get_id_GUGroupIDToDeleteList() const { return get<GUGroupIDList>(5); }
34413                 CoverageModificationList& select_id_CoverageModificationList() { return set<CoverageModificationList>(6); }
34414                 CoverageModificationList const* get_id_CoverageModificationList() const { return get<CoverageModificationList>(6); }
34415                 bool is_unknown() const { return type == 7; }
34416                 void clear()
34417                 {
34418                         switch(type)
34419                         {
34420                         case 1: var.destroy<ServedCells>(); break;
34421                         case 2: var.destroy<ServedCellsToModify>(); break;
34422                         case 3: var.destroy<Old_ECGIs>(); break;
34423                         case 4: var.destroy<GUGroupIDList>(); break;
34424                         case 5: var.destroy<GUGroupIDList>(); break;
34425                         case 6: var.destroy<CoverageModificationList>(); break;
34426                         }
34427                         type = 0; ref_nested().clear();
34428                 }
34429                 template<typename V> static inline void enumerate(V& v)
34430                 {
34431                         v.template operator()<ServedCells>(1);
34432                         v.template operator()<ServedCellsToModify>(2);
34433                         v.template operator()<Old_ECGIs>(3);
34434                         v.template operator()<GUGroupIDList>(4);
34435                         v.template operator()<GUGroupIDList>(5);
34436                         v.template operator()<CoverageModificationList>(6);
34437
34438                 }
34439                 protected:
34440                 template<typename V> bool decode(size_t index, V& v)
34441                 {
34442                         clear();
34443                         switch(index)
34444                         {
34445                         case 1: v(select_id_ServedCellsToAdd()); return true;
34446                         case 2: v(select_id_ServedCellsToModify()); return true;
34447                         case 3: v(select_id_ServedCellsToDelete()); return true;
34448                         case 4: v(select_id_GUGroupIDToAddList()); return true;
34449                         case 5: v(select_id_GUGroupIDToDeleteList()); return true;
34450                         case 6: v(select_id_CoverageModificationList()); return true;
34451                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
34452                         }
34453                         return false;
34454
34455                 }
34456                 template<typename V> bool encode(size_t index, V& v) const
34457                 {
34458                         if(index != type) return false;
34459                         switch(type)
34460                         {
34461                         case 1: v(var.as<ServedCells>()); return true;
34462                         case 2: v(var.as<ServedCellsToModify>()); return true;
34463                         case 3: v(var.as<Old_ECGIs>()); return true;
34464                         case 4: v(var.as<GUGroupIDList>()); return true;
34465                         case 5: v(var.as<GUGroupIDList>()); return true;
34466                         case 6: v(var.as<CoverageModificationList>()); return true;
34467                         }
34468                         return false;
34469
34470                 }
34471                 private:
34472                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34473                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34474                 union union_type
34475                 {
34476                         char dummy1[sizeof(CoverageModificationList)];
34477                         char dummy2[sizeof(GUGroupIDList)];
34478                         char dummy3[sizeof(Old_ECGIs)];
34479                         char dummy4[sizeof(ServedCells)];
34480                         char dummy5[sizeof(ServedCellsToModify)];
34481
34482                 };
34483                 asn::variant<sizeof(union_type)> var;
34484                 size_t type {0};
34485
34486         };
34487         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34488         {
34489                 size_t get_index() const {return type;}
34490                 bool is_unknown() const { return type == 7; }
34491                 void clear() {type = 0;}
34492                 void select_id_ServedCellsToAdd() { set(optional); type=1;}
34493                 void select_id_ServedCellsToModify() { set(optional); type=2;}
34494                 void select_id_ServedCellsToDelete() { set(optional); type=3;}
34495                 void select_id_GUGroupIDToAddList() { set(optional); type=4;}
34496                 void select_id_GUGroupIDToDeleteList() { set(optional); type=5;}
34497                 void select_id_CoverageModificationList() { set(optional); type=6;}
34498                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
34499                 template<typename V>  bool decode(V& v)
34500                 {
34501                         clear();
34502                         if(!v(ref_nested())) return false;
34503                         if(equal(optional)) { type = 1; return true; }
34504                         else if(equal(optional)) { type = 2; return true; }
34505                         else if(equal(optional)) { type = 3; return true; }
34506                         else if(equal(optional)) { type = 4; return true; }
34507                         else if(equal(optional)) { type = 5; return true; }
34508                         else if(equal(optional)) { type = 6; return true; }
34509                         else { type = 7; return true;}
34510                         return false;
34511
34512                 }
34513                 template<typename V> bool encode(V& v) const
34514                 {
34515                         return v(ref_nested());
34516
34517                 }
34518                 protected:
34519                 template<typename V>  bool decode(size_t index, V& v)
34520                 {
34521                         clear();
34522                         switch(index)
34523                         {
34524                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34525                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
34526                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
34527                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
34528                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
34529                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
34530                         case 7: type = 7; return v(ref_nested());
34531                         ref_nested().clear();
34532                         }
34533                         return false;
34534
34535                 }
34536                 template<typename V> bool encode(size_t index, V& v) const
34537                 {
34538                         if(index != type) {return false;} return v(ref_nested());
34539
34540                 }
34541                 private:
34542                 size_t type {0};
34543
34544         };
34545
34546 };
34547 /*
34548 ENBConfigurationUpdate ::= SEQUENCE {
34549         protocolIEs             ProtocolIE-Container    {{ENBConfigurationUpdate-IEs}},
34550         ...
34551 }
34552 */
34553
34554 struct ENBConfigurationUpdate : asn::sequence<1, 0, true, 0>
34555 {
34556         static constexpr const char* name() {return "ENBConfigurationUpdate";}
34557         using parent_t = asn::sequence<1, 0, true, 0>;
34558         struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdate_IEs>
34559         {
34560                 static constexpr const char* name() {return "protocolIEs_t";}
34561                 using parent_t = ProtocolIE_Container<ENBConfigurationUpdate_IEs>;
34562
34563         };
34564         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
34565         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
34566         template<typename V> void decode(V& v)
34567         {
34568                 v(protocolIEs);
34569
34570         };
34571         template<typename V> void encode(V& v) const
34572         {
34573                 v(protocolIEs);
34574
34575         };
34576         void clear()
34577         {
34578                 protocolIEs.clear();
34579
34580         };
34581         private:
34582         protocolIEs_t   protocolIEs;
34583
34584 };
34585 /*
34586 ENBConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
34587         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional},
34588 ...
34589 }
34590 */
34591
34592 struct ENBConfigurationUpdateAcknowledge_IEs
34593 {
34594         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34595         {
34596                 size_t get_index() const {return type;}
34597                 bool is_unknown() const { return type == 2; }
34598                 void clear() {type = 0;}
34599                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=1;}
34600                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34601                 template<typename V>  bool decode(V& v)
34602                 {
34603                         clear();
34604                         if(!v(ref_nested())) return false;
34605                         if(equal(id_CriticalityDiagnostics)) { type = 1; return true; }
34606                         else { type = 2; return true;}
34607                         return false;
34608
34609                 }
34610                 template<typename V> bool encode(V& v) const
34611                 {
34612                         return v(ref_nested());
34613
34614                 }
34615                 protected:
34616                 template<typename V>  bool decode(size_t index, V& v)
34617                 {
34618                         clear();
34619                         switch(index)
34620                         {
34621                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
34622                         case 2: type = 2; return v(ref_nested());
34623                         ref_nested().clear();
34624                         }
34625                         return false;
34626
34627                 }
34628                 template<typename V> bool encode(size_t index, V& v) const
34629                 {
34630                         if(index != type) {return false;} return v(ref_nested());
34631
34632                 }
34633                 private:
34634                 size_t type {0};
34635
34636         };
34637         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34638         {
34639                 size_t get_index() const {return type;}
34640                 bool is_unknown() const { return type == 2; }
34641                 void clear() {type = 0;}
34642                 void select_id_CriticalityDiagnostics() { set(ignore); type=1;}
34643                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34644                 template<typename V>  bool decode(V& v)
34645                 {
34646                         clear();
34647                         if(!v(ref_nested())) return false;
34648                         if(equal(ignore)) { type = 1; return true; }
34649                         else { type = 2; return true;}
34650                         return false;
34651
34652                 }
34653                 template<typename V> bool encode(V& v) const
34654                 {
34655                         return v(ref_nested());
34656
34657                 }
34658                 protected:
34659                 template<typename V>  bool decode(size_t index, V& v)
34660                 {
34661                         clear();
34662                         switch(index)
34663                         {
34664                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34665                         case 2: type = 2; return v(ref_nested());
34666                         ref_nested().clear();
34667                         }
34668                         return false;
34669
34670                 }
34671                 template<typename V> bool encode(size_t index, V& v) const
34672                 {
34673                         if(index != type) {return false;} return v(ref_nested());
34674
34675                 }
34676                 private:
34677                 size_t type {0};
34678
34679         };
34680         struct Value_t : asn::typefield<true>
34681         {
34682                 ~Value_t()      {clear();}
34683                 size_t get_index() const {return type;}
34684                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
34685                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
34686                 bool is_unknown() const { return type == 2; }
34687                 void clear()
34688                 {
34689                         switch(type)
34690                         {
34691                         case 1: var.destroy<CriticalityDiagnostics>(); break;
34692                         }
34693                         type = 0; ref_nested().clear();
34694                 }
34695                 template<typename V> static inline void enumerate(V& v)
34696                 {
34697                         v.template operator()<CriticalityDiagnostics>(1);
34698
34699                 }
34700                 protected:
34701                 template<typename V> bool decode(size_t index, V& v)
34702                 {
34703                         clear();
34704                         switch(index)
34705                         {
34706                         case 1: v(select_id_CriticalityDiagnostics()); return true;
34707                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
34708                         }
34709                         return false;
34710
34711                 }
34712                 template<typename V> bool encode(size_t index, V& v) const
34713                 {
34714                         if(index != type) return false;
34715                         switch(type)
34716                         {
34717                         case 1: v(var.as<CriticalityDiagnostics>()); return true;
34718                         }
34719                         return false;
34720
34721                 }
34722                 private:
34723                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34724                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34725                 union union_type
34726                 {
34727                         char dummy1[sizeof(CriticalityDiagnostics)];
34728
34729                 };
34730                 asn::variant<sizeof(union_type)> var;
34731                 size_t type {0};
34732
34733         };
34734         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34735         {
34736                 size_t get_index() const {return type;}
34737                 bool is_unknown() const { return type == 2; }
34738                 void clear() {type = 0;}
34739                 void select_id_CriticalityDiagnostics() { set(optional); type=1;}
34740                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
34741                 template<typename V>  bool decode(V& v)
34742                 {
34743                         clear();
34744                         if(!v(ref_nested())) return false;
34745                         if(equal(optional)) { type = 1; return true; }
34746                         else { type = 2; return true;}
34747                         return false;
34748
34749                 }
34750                 template<typename V> bool encode(V& v) const
34751                 {
34752                         return v(ref_nested());
34753
34754                 }
34755                 protected:
34756                 template<typename V>  bool decode(size_t index, V& v)
34757                 {
34758                         clear();
34759                         switch(index)
34760                         {
34761                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34762                         case 2: type = 2; return v(ref_nested());
34763                         ref_nested().clear();
34764                         }
34765                         return false;
34766
34767                 }
34768                 template<typename V> bool encode(size_t index, V& v) const
34769                 {
34770                         if(index != type) {return false;} return v(ref_nested());
34771
34772                 }
34773                 private:
34774                 size_t type {0};
34775
34776         };
34777
34778 };
34779 /*
34780 ENBConfigurationUpdateAcknowledge ::= SEQUENCE {
34781         protocolIEs             ProtocolIE-Container    {{ENBConfigurationUpdateAcknowledge-IEs}},
34782         ...
34783 }
34784 */
34785
34786 struct ENBConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
34787 {
34788         static constexpr const char* name() {return "ENBConfigurationUpdateAcknowledge";}
34789         using parent_t = asn::sequence<1, 0, true, 0>;
34790         struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>
34791         {
34792                 static constexpr const char* name() {return "protocolIEs_t";}
34793                 using parent_t = ProtocolIE_Container<ENBConfigurationUpdateAcknowledge_IEs>;
34794
34795         };
34796         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
34797         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
34798         template<typename V> void decode(V& v)
34799         {
34800                 v(protocolIEs);
34801
34802         };
34803         template<typename V> void encode(V& v) const
34804         {
34805                 v(protocolIEs);
34806
34807         };
34808         void clear()
34809         {
34810                 protocolIEs.clear();
34811
34812         };
34813         private:
34814         protocolIEs_t   protocolIEs;
34815
34816 };
34817 /*
34818 ENBConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
34819         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
34820         { ID id-TimeToWait                                      CRITICALITY ignore      TYPE TimeToWait                                 PRESENCE optional}|
34821         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional},
34822         ...
34823 }
34824 */
34825
34826 struct ENBConfigurationUpdateFailure_IEs
34827 {
34828         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
34829         {
34830                 size_t get_index() const {return type;}
34831                 bool is_unknown() const { return type == 4; }
34832                 void clear() {type = 0;}
34833                 void select_id_Cause() { set(id_Cause); type=1;}
34834                 void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
34835                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
34836                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
34837                 template<typename V>  bool decode(V& v)
34838                 {
34839                         clear();
34840                         if(!v(ref_nested())) return false;
34841                         if(equal(id_Cause)) { type = 1; return true; }
34842                         else if(equal(id_TimeToWait)) { type = 2; return true; }
34843                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
34844                         else { type = 4; return true;}
34845                         return false;
34846
34847                 }
34848                 template<typename V> bool encode(V& v) const
34849                 {
34850                         return v(ref_nested());
34851
34852                 }
34853                 protected:
34854                 template<typename V>  bool decode(size_t index, V& v)
34855                 {
34856                         clear();
34857                         switch(index)
34858                         {
34859                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
34860                         case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
34861                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
34862                         case 4: type = 4; return v(ref_nested());
34863                         ref_nested().clear();
34864                         }
34865                         return false;
34866
34867                 }
34868                 template<typename V> bool encode(size_t index, V& v) const
34869                 {
34870                         if(index != type) {return false;} return v(ref_nested());
34871
34872                 }
34873                 private:
34874                 size_t type {0};
34875
34876         };
34877         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
34878         {
34879                 size_t get_index() const {return type;}
34880                 bool is_unknown() const { return type == 4; }
34881                 void clear() {type = 0;}
34882                 void select_id_Cause() { set(ignore); type=1;}
34883                 void select_id_TimeToWait() { set(ignore); type=2;}
34884                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
34885                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
34886                 template<typename V>  bool decode(V& v)
34887                 {
34888                         clear();
34889                         if(!v(ref_nested())) return false;
34890                         if(equal(ignore)) { type = 1; return true; }
34891                         else if(equal(ignore)) { type = 2; return true; }
34892                         else if(equal(ignore)) { type = 3; return true; }
34893                         else { type = 4; return true;}
34894                         return false;
34895
34896                 }
34897                 template<typename V> bool encode(V& v) const
34898                 {
34899                         return v(ref_nested());
34900
34901                 }
34902                 protected:
34903                 template<typename V>  bool decode(size_t index, V& v)
34904                 {
34905                         clear();
34906                         switch(index)
34907                         {
34908                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34909                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
34910                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
34911                         case 4: type = 4; return v(ref_nested());
34912                         ref_nested().clear();
34913                         }
34914                         return false;
34915
34916                 }
34917                 template<typename V> bool encode(size_t index, V& v) const
34918                 {
34919                         if(index != type) {return false;} return v(ref_nested());
34920
34921                 }
34922                 private:
34923                 size_t type {0};
34924
34925         };
34926         struct Value_t : asn::typefield<true>
34927         {
34928                 ~Value_t()      {clear();}
34929                 size_t get_index() const {return type;}
34930                 Cause& select_id_Cause() { return set<Cause>(1); }
34931                 Cause const* get_id_Cause() const { return get<Cause>(1); }
34932                 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
34933                 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
34934                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
34935                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
34936                 bool is_unknown() const { return type == 4; }
34937                 void clear()
34938                 {
34939                         switch(type)
34940                         {
34941                         case 1: var.destroy<Cause>(); break;
34942                         case 2: var.destroy<TimeToWait>(); break;
34943                         case 3: var.destroy<CriticalityDiagnostics>(); break;
34944                         }
34945                         type = 0; ref_nested().clear();
34946                 }
34947                 template<typename V> static inline void enumerate(V& v)
34948                 {
34949                         v.template operator()<Cause>(1);
34950                         v.template operator()<TimeToWait>(2);
34951                         v.template operator()<CriticalityDiagnostics>(3);
34952
34953                 }
34954                 protected:
34955                 template<typename V> bool decode(size_t index, V& v)
34956                 {
34957                         clear();
34958                         switch(index)
34959                         {
34960                         case 1: v(select_id_Cause()); return true;
34961                         case 2: v(select_id_TimeToWait()); return true;
34962                         case 3: v(select_id_CriticalityDiagnostics()); return true;
34963                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
34964                         }
34965                         return false;
34966
34967                 }
34968                 template<typename V> bool encode(size_t index, V& v) const
34969                 {
34970                         if(index != type) return false;
34971                         switch(type)
34972                         {
34973                         case 1: v(var.as<Cause>()); return true;
34974                         case 2: v(var.as<TimeToWait>()); return true;
34975                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
34976                         }
34977                         return false;
34978
34979                 }
34980                 private:
34981                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34982                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34983                 union union_type
34984                 {
34985                         char dummy1[sizeof(Cause)];
34986                         char dummy2[sizeof(CriticalityDiagnostics)];
34987                         char dummy3[sizeof(TimeToWait)];
34988
34989                 };
34990                 asn::variant<sizeof(union_type)> var;
34991                 size_t type {0};
34992
34993         };
34994         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
34995         {
34996                 size_t get_index() const {return type;}
34997                 bool is_unknown() const { return type == 4; }
34998                 void clear() {type = 0;}
34999                 void select_id_Cause() { set(mandatory); type=1;}
35000                 void select_id_TimeToWait() { set(optional); type=2;}
35001                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
35002                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35003                 template<typename V>  bool decode(V& v)
35004                 {
35005                         clear();
35006                         if(!v(ref_nested())) return false;
35007                         if(equal(mandatory)) { type = 1; return true; }
35008                         else if(equal(optional)) { type = 2; return true; }
35009                         else if(equal(optional)) { type = 3; return true; }
35010                         else { type = 4; return true;}
35011                         return false;
35012
35013                 }
35014                 template<typename V> bool encode(V& v) const
35015                 {
35016                         return v(ref_nested());
35017
35018                 }
35019                 protected:
35020                 template<typename V>  bool decode(size_t index, V& v)
35021                 {
35022                         clear();
35023                         switch(index)
35024                         {
35025                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35026                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
35027                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
35028                         case 4: type = 4; return v(ref_nested());
35029                         ref_nested().clear();
35030                         }
35031                         return false;
35032
35033                 }
35034                 template<typename V> bool encode(size_t index, V& v) const
35035                 {
35036                         if(index != type) {return false;} return v(ref_nested());
35037
35038                 }
35039                 private:
35040                 size_t type {0};
35041
35042         };
35043
35044 };
35045 /*
35046 ENBConfigurationUpdateFailure ::= SEQUENCE {
35047         protocolIEs             ProtocolIE-Container    {{ENBConfigurationUpdateFailure-IEs}},
35048         ...
35049 }
35050 */
35051
35052 struct ENBConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
35053 {
35054         static constexpr const char* name() {return "ENBConfigurationUpdateFailure";}
35055         using parent_t = asn::sequence<1, 0, true, 0>;
35056         struct protocolIEs_t : ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>
35057         {
35058                 static constexpr const char* name() {return "protocolIEs_t";}
35059                 using parent_t = ProtocolIE_Container<ENBConfigurationUpdateFailure_IEs>;
35060
35061         };
35062         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35063         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35064         template<typename V> void decode(V& v)
35065         {
35066                 v(protocolIEs);
35067
35068         };
35069         template<typename V> void encode(V& v) const
35070         {
35071                 v(protocolIEs);
35072
35073         };
35074         void clear()
35075         {
35076                 protocolIEs.clear();
35077
35078         };
35079         private:
35080         protocolIEs_t   protocolIEs;
35081
35082 };
35083 /*
35084 ENDCCellActivationFailure-IEs X2AP-PROTOCOL-IES ::= {
35085         { ID id-ActivationID                                    CRITICALITY reject      TYPE ActivationID                               PRESENCE mandatory }|
35086         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory }|
35087         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional },
35088         ...
35089 }
35090 */
35091
35092 struct ENDCCellActivationFailure_IEs
35093 {
35094         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35095         {
35096                 size_t get_index() const {return type;}
35097                 bool is_unknown() const { return type == 4; }
35098                 void clear() {type = 0;}
35099                 void select_id_ActivationID() { set(id_ActivationID); type=1;}
35100                 void select_id_Cause() { set(id_Cause); type=2;}
35101                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
35102                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35103                 template<typename V>  bool decode(V& v)
35104                 {
35105                         clear();
35106                         if(!v(ref_nested())) return false;
35107                         if(equal(id_ActivationID)) { type = 1; return true; }
35108                         else if(equal(id_Cause)) { type = 2; return true; }
35109                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
35110                         else { type = 4; return true;}
35111                         return false;
35112
35113                 }
35114                 template<typename V> bool encode(V& v) const
35115                 {
35116                         return v(ref_nested());
35117
35118                 }
35119                 protected:
35120                 template<typename V>  bool decode(size_t index, V& v)
35121                 {
35122                         clear();
35123                         switch(index)
35124                         {
35125                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35126                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
35127                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
35128                         case 4: type = 4; return v(ref_nested());
35129                         ref_nested().clear();
35130                         }
35131                         return false;
35132
35133                 }
35134                 template<typename V> bool encode(size_t index, V& v) const
35135                 {
35136                         if(index != type) {return false;} return v(ref_nested());
35137
35138                 }
35139                 private:
35140                 size_t type {0};
35141
35142         };
35143         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35144         {
35145                 size_t get_index() const {return type;}
35146                 bool is_unknown() const { return type == 4; }
35147                 void clear() {type = 0;}
35148                 void select_id_ActivationID() { set(reject); type=1;}
35149                 void select_id_Cause() { set(ignore); type=2;}
35150                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
35151                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35152                 template<typename V>  bool decode(V& v)
35153                 {
35154                         clear();
35155                         if(!v(ref_nested())) return false;
35156                         if(equal(reject)) { type = 1; return true; }
35157                         else if(equal(ignore)) { type = 2; return true; }
35158                         else if(equal(ignore)) { type = 3; return true; }
35159                         else { type = 4; return true;}
35160                         return false;
35161
35162                 }
35163                 template<typename V> bool encode(V& v) const
35164                 {
35165                         return v(ref_nested());
35166
35167                 }
35168                 protected:
35169                 template<typename V>  bool decode(size_t index, V& v)
35170                 {
35171                         clear();
35172                         switch(index)
35173                         {
35174                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
35175                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
35176                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
35177                         case 4: type = 4; return v(ref_nested());
35178                         ref_nested().clear();
35179                         }
35180                         return false;
35181
35182                 }
35183                 template<typename V> bool encode(size_t index, V& v) const
35184                 {
35185                         if(index != type) {return false;} return v(ref_nested());
35186
35187                 }
35188                 private:
35189                 size_t type {0};
35190
35191         };
35192         struct Value_t : asn::typefield<true>
35193         {
35194                 ~Value_t()      {clear();}
35195                 size_t get_index() const {return type;}
35196                 ActivationID& select_id_ActivationID() { return set<ActivationID>(1); }
35197                 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(1); }
35198                 Cause& select_id_Cause() { return set<Cause>(2); }
35199                 Cause const* get_id_Cause() const { return get<Cause>(2); }
35200                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
35201                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
35202                 bool is_unknown() const { return type == 4; }
35203                 void clear()
35204                 {
35205                         switch(type)
35206                         {
35207                         case 1: var.destroy<ActivationID>(); break;
35208                         case 2: var.destroy<Cause>(); break;
35209                         case 3: var.destroy<CriticalityDiagnostics>(); break;
35210                         }
35211                         type = 0; ref_nested().clear();
35212                 }
35213                 template<typename V> static inline void enumerate(V& v)
35214                 {
35215                         v.template operator()<ActivationID>(1);
35216                         v.template operator()<Cause>(2);
35217                         v.template operator()<CriticalityDiagnostics>(3);
35218
35219                 }
35220                 protected:
35221                 template<typename V> bool decode(size_t index, V& v)
35222                 {
35223                         clear();
35224                         switch(index)
35225                         {
35226                         case 1: v(select_id_ActivationID()); return true;
35227                         case 2: v(select_id_Cause()); return true;
35228                         case 3: v(select_id_CriticalityDiagnostics()); return true;
35229                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
35230                         }
35231                         return false;
35232
35233                 }
35234                 template<typename V> bool encode(size_t index, V& v) const
35235                 {
35236                         if(index != type) return false;
35237                         switch(type)
35238                         {
35239                         case 1: v(var.as<ActivationID>()); return true;
35240                         case 2: v(var.as<Cause>()); return true;
35241                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
35242                         }
35243                         return false;
35244
35245                 }
35246                 private:
35247                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35248                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35249                 union union_type
35250                 {
35251                         char dummy1[sizeof(ActivationID)];
35252                         char dummy2[sizeof(Cause)];
35253                         char dummy3[sizeof(CriticalityDiagnostics)];
35254
35255                 };
35256                 asn::variant<sizeof(union_type)> var;
35257                 size_t type {0};
35258
35259         };
35260         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
35261         {
35262                 size_t get_index() const {return type;}
35263                 bool is_unknown() const { return type == 4; }
35264                 void clear() {type = 0;}
35265                 void select_id_ActivationID() { set(mandatory); type=1;}
35266                 void select_id_Cause() { set(mandatory); type=2;}
35267                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
35268                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35269                 template<typename V>  bool decode(V& v)
35270                 {
35271                         clear();
35272                         if(!v(ref_nested())) return false;
35273                         if(equal(mandatory)) { type = 1; return true; }
35274                         else if(equal(mandatory)) { type = 2; return true; }
35275                         else if(equal(optional)) { type = 3; return true; }
35276                         else { type = 4; return true;}
35277                         return false;
35278
35279                 }
35280                 template<typename V> bool encode(V& v) const
35281                 {
35282                         return v(ref_nested());
35283
35284                 }
35285                 protected:
35286                 template<typename V>  bool decode(size_t index, V& v)
35287                 {
35288                         clear();
35289                         switch(index)
35290                         {
35291                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35292                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
35293                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
35294                         case 4: type = 4; return v(ref_nested());
35295                         ref_nested().clear();
35296                         }
35297                         return false;
35298
35299                 }
35300                 template<typename V> bool encode(size_t index, V& v) const
35301                 {
35302                         if(index != type) {return false;} return v(ref_nested());
35303
35304                 }
35305                 private:
35306                 size_t type {0};
35307
35308         };
35309
35310 };
35311 /*
35312 ENDCCellActivationFailure ::= SEQUENCE {
35313         protocolIEs             ProtocolIE-Container    {{ENDCCellActivationFailure-IEs}},
35314         ...
35315 }
35316 */
35317
35318 struct ENDCCellActivationFailure : asn::sequence<1, 0, true, 0>
35319 {
35320         static constexpr const char* name() {return "ENDCCellActivationFailure";}
35321         using parent_t = asn::sequence<1, 0, true, 0>;
35322         struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationFailure_IEs>
35323         {
35324                 static constexpr const char* name() {return "protocolIEs_t";}
35325                 using parent_t = ProtocolIE_Container<ENDCCellActivationFailure_IEs>;
35326
35327         };
35328         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35329         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35330         template<typename V> void decode(V& v)
35331         {
35332                 v(protocolIEs);
35333
35334         };
35335         template<typename V> void encode(V& v) const
35336         {
35337                 v(protocolIEs);
35338
35339         };
35340         void clear()
35341         {
35342                 protocolIEs.clear();
35343
35344         };
35345         private:
35346         protocolIEs_t   protocolIEs;
35347
35348 };
35349 /*
35350 ServedNRCellsToActivate-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35351         ...
35352 }
35353 */
35354
35355 struct ServedNRCellsToActivate_Item_ExtIEs
35356 {
35357         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35358         {
35359                 size_t get_index() const {return type;}
35360                 bool is_unknown() const { return type == 1; }
35361                 void clear() {type = 0;}
35362                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35363                 template<typename V>  bool decode(V& v)
35364                 {
35365                         clear();
35366                         if(!v(ref_nested())) return false;
35367                         { type = 1; return true;}
35368                         return false;
35369
35370                 }
35371                 template<typename V> bool encode(V& v) const
35372                 {
35373                         return v(ref_nested());
35374
35375                 }
35376                 protected:
35377                 template<typename V>  bool decode(size_t index, V& v)
35378                 {
35379                         clear();
35380                         switch(index)
35381                         {
35382                         case 1: type = 1; return v(ref_nested());
35383                         ref_nested().clear();
35384                         }
35385                         return false;
35386
35387                 }
35388                 template<typename V> bool encode(size_t index, V& v) const
35389                 {
35390                         if(index != type) {return false;} return v(ref_nested());
35391
35392                 }
35393                 private:
35394                 size_t type {0};
35395
35396         };
35397         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35398         {
35399                 size_t get_index() const {return type;}
35400                 bool is_unknown() const { return type == 1; }
35401                 void clear() {type = 0;}
35402                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35403                 template<typename V>  bool decode(V& v)
35404                 {
35405                         clear();
35406                         if(!v(ref_nested())) return false;
35407                         { type = 1; return true;}
35408                         return false;
35409
35410                 }
35411                 template<typename V> bool encode(V& v) const
35412                 {
35413                         return v(ref_nested());
35414
35415                 }
35416                 protected:
35417                 template<typename V>  bool decode(size_t index, V& v)
35418                 {
35419                         clear();
35420                         switch(index)
35421                         {
35422                         case 1: type = 1; return v(ref_nested());
35423                         ref_nested().clear();
35424                         }
35425                         return false;
35426
35427                 }
35428                 template<typename V> bool encode(size_t index, V& v) const
35429                 {
35430                         if(index != type) {return false;} return v(ref_nested());
35431
35432                 }
35433                 private:
35434                 size_t type {0};
35435
35436         };
35437         struct Extension_t : asn::typefield<true>
35438         {
35439                 ~Extension_t()  {clear();}
35440                 size_t get_index() const {return type;}
35441                 bool is_unknown() const { return type == 1; }
35442                 void clear()
35443                 {
35444                         type = 0; ref_nested().clear();
35445                 }
35446                 template<typename V> static inline void enumerate(V& v)
35447                 {
35448
35449                 }
35450                 protected:
35451                 template<typename V> bool decode(size_t index, V& v)
35452                 {
35453                         clear();
35454                         switch(index)
35455                         {
35456                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35457                         }
35458                         return false;
35459
35460                 }
35461                 template<typename V> bool encode(size_t index, V& v) const
35462                 {
35463                         if(index != type) return false;
35464                         return false;
35465
35466                 }
35467                 private:
35468                 size_t type {0};
35469
35470         };
35471         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35472         {
35473                 size_t get_index() const {return type;}
35474                 bool is_unknown() const { return type == 1; }
35475                 void clear() {type = 0;}
35476                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35477                 template<typename V>  bool decode(V& v)
35478                 {
35479                         clear();
35480                         if(!v(ref_nested())) return false;
35481                         { type = 1; return true;}
35482                         return false;
35483
35484                 }
35485                 template<typename V> bool encode(V& v) const
35486                 {
35487                         return v(ref_nested());
35488
35489                 }
35490                 protected:
35491                 template<typename V>  bool decode(size_t index, V& v)
35492                 {
35493                         clear();
35494                         switch(index)
35495                         {
35496                         case 1: type = 1; return v(ref_nested());
35497                         ref_nested().clear();
35498                         }
35499                         return false;
35500
35501                 }
35502                 template<typename V> bool encode(size_t index, V& v) const
35503                 {
35504                         if(index != type) {return false;} return v(ref_nested());
35505
35506                 }
35507                 private:
35508                 size_t type {0};
35509
35510         };
35511
35512 };
35513 /*
35514 ServedNRCellsToActivate-Item::= SEQUENCE {
35515         nrCellID                                                NRCGI,
35516         iE-Extensions                                   ProtocolExtensionContainer { {ServedNRCellsToActivate-Item-ExtIEs} } OPTIONAL,
35517         ...
35518 }
35519 */
35520
35521 struct ServedNRCellsToActivate_Item : asn::sequence<2, 0, true, 1>
35522 {
35523         static constexpr const char* name() {return "ServedNRCellsToActivate-Item";}
35524         using parent_t = asn::sequence<2, 0, true, 1>;
35525         struct nrCellID_t : NRCGI
35526         {
35527                 static constexpr const char* name() {return "nrCellID_t";}
35528                 using parent_t = NRCGI;
35529
35530         };
35531         nrCellID_t& ref_nrCellID() {return nrCellID;}
35532         nrCellID_t const& ref_nrCellID() const {return nrCellID;}
35533         struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToActivate_Item_ExtIEs>
35534         {
35535                 static constexpr const char* name() {return "iE_Extensions_t";}
35536                 using parent_t = ProtocolExtensionContainer<ServedNRCellsToActivate_Item_ExtIEs>;
35537                 static constexpr bool optional = true;
35538
35539         };
35540         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35541         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35542         template<typename V> void decode(V& v)
35543         {
35544                 v(nrCellID);
35545                 v(iE_Extensions);
35546
35547         };
35548         template<typename V> void encode(V& v) const
35549         {
35550                 v(nrCellID);
35551                 v(iE_Extensions);
35552
35553         };
35554         void clear()
35555         {
35556                 nrCellID.clear();
35557                 iE_Extensions.clear();
35558
35559         };
35560         private:
35561         nrCellID_t      nrCellID;
35562         iE_Extensions_t iE_Extensions;
35563
35564 };
35565 /*
35566 ServedNRCellsToActivate::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF ServedNRCellsToActivate-Item
35567 */
35568
35569 struct ServedNRCellsToActivate_elm : ServedNRCellsToActivate_Item
35570 {
35571         static constexpr const char* name() {return "ServedNRCellsToActivate_elm";}
35572         using parent_t = ServedNRCellsToActivate_Item;
35573
35574 };
35575 struct ServedNRCellsToActivate : asn::sequenceof<ServedNRCellsToActivate_elm>
35576 {
35577         static constexpr const char* name() {return "ServedNRCellsToActivate";}
35578         using parent_t = asn::sequenceof<ServedNRCellsToActivate_elm>;
35579         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
35580
35581 };
35582 /*
35583 ENDCCellActivationRequest-IEs X2AP-PROTOCOL-IES ::= {
35584         { ID id-ServedNRCellsToActivate         CRITICALITY reject      TYPE ServedNRCellsToActivate                    PRESENCE mandatory}|
35585         { ID id-ActivationID                            CRITICALITY reject      TYPE ActivationID                                       PRESENCE mandatory},
35586         ...
35587 }
35588 */
35589
35590 struct ENDCCellActivationRequest_IEs
35591 {
35592         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35593         {
35594                 size_t get_index() const {return type;}
35595                 bool is_unknown() const { return type == 3; }
35596                 void clear() {type = 0;}
35597                 void select_id_ServedNRCellsToActivate() { set(id_ServedNRCellsToActivate); type=1;}
35598                 void select_id_ActivationID() { set(id_ActivationID); type=2;}
35599                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35600                 template<typename V>  bool decode(V& v)
35601                 {
35602                         clear();
35603                         if(!v(ref_nested())) return false;
35604                         if(equal(id_ServedNRCellsToActivate)) { type = 1; return true; }
35605                         else if(equal(id_ActivationID)) { type = 2; return true; }
35606                         else { type = 3; return true;}
35607                         return false;
35608
35609                 }
35610                 template<typename V> bool encode(V& v) const
35611                 {
35612                         return v(ref_nested());
35613
35614                 }
35615                 protected:
35616                 template<typename V>  bool decode(size_t index, V& v)
35617                 {
35618                         clear();
35619                         switch(index)
35620                         {
35621                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRCellsToActivate);} return false;
35622                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35623                         case 3: type = 3; return v(ref_nested());
35624                         ref_nested().clear();
35625                         }
35626                         return false;
35627
35628                 }
35629                 template<typename V> bool encode(size_t index, V& v) const
35630                 {
35631                         if(index != type) {return false;} return v(ref_nested());
35632
35633                 }
35634                 private:
35635                 size_t type {0};
35636
35637         };
35638         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35639         {
35640                 size_t get_index() const {return type;}
35641                 bool is_unknown() const { return type == 3; }
35642                 void clear() {type = 0;}
35643                 void select_id_ServedNRCellsToActivate() { set(reject); type=1;}
35644                 void select_id_ActivationID() { set(reject); type=2;}
35645                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35646                 template<typename V>  bool decode(V& v)
35647                 {
35648                         clear();
35649                         if(!v(ref_nested())) return false;
35650                         if(equal(reject)) { type = 1; return true; }
35651                         else if(equal(reject)) { type = 2; return true; }
35652                         else { type = 3; return true;}
35653                         return false;
35654
35655                 }
35656                 template<typename V> bool encode(V& v) const
35657                 {
35658                         return v(ref_nested());
35659
35660                 }
35661                 protected:
35662                 template<typename V>  bool decode(size_t index, V& v)
35663                 {
35664                         clear();
35665                         switch(index)
35666                         {
35667                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
35668                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
35669                         case 3: type = 3; return v(ref_nested());
35670                         ref_nested().clear();
35671                         }
35672                         return false;
35673
35674                 }
35675                 template<typename V> bool encode(size_t index, V& v) const
35676                 {
35677                         if(index != type) {return false;} return v(ref_nested());
35678
35679                 }
35680                 private:
35681                 size_t type {0};
35682
35683         };
35684         struct Value_t : asn::typefield<true>
35685         {
35686                 ~Value_t()      {clear();}
35687                 size_t get_index() const {return type;}
35688                 ServedNRCellsToActivate& select_id_ServedNRCellsToActivate() { return set<ServedNRCellsToActivate>(1); }
35689                 ServedNRCellsToActivate const* get_id_ServedNRCellsToActivate() const { return get<ServedNRCellsToActivate>(1); }
35690                 ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
35691                 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
35692                 bool is_unknown() const { return type == 3; }
35693                 void clear()
35694                 {
35695                         switch(type)
35696                         {
35697                         case 1: var.destroy<ServedNRCellsToActivate>(); break;
35698                         case 2: var.destroy<ActivationID>(); break;
35699                         }
35700                         type = 0; ref_nested().clear();
35701                 }
35702                 template<typename V> static inline void enumerate(V& v)
35703                 {
35704                         v.template operator()<ServedNRCellsToActivate>(1);
35705                         v.template operator()<ActivationID>(2);
35706
35707                 }
35708                 protected:
35709                 template<typename V> bool decode(size_t index, V& v)
35710                 {
35711                         clear();
35712                         switch(index)
35713                         {
35714                         case 1: v(select_id_ServedNRCellsToActivate()); return true;
35715                         case 2: v(select_id_ActivationID()); return true;
35716                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
35717                         }
35718                         return false;
35719
35720                 }
35721                 template<typename V> bool encode(size_t index, V& v) const
35722                 {
35723                         if(index != type) return false;
35724                         switch(type)
35725                         {
35726                         case 1: v(var.as<ServedNRCellsToActivate>()); return true;
35727                         case 2: v(var.as<ActivationID>()); return true;
35728                         }
35729                         return false;
35730
35731                 }
35732                 private:
35733                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35734                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35735                 union union_type
35736                 {
35737                         char dummy1[sizeof(ActivationID)];
35738                         char dummy2[sizeof(ServedNRCellsToActivate)];
35739
35740                 };
35741                 asn::variant<sizeof(union_type)> var;
35742                 size_t type {0};
35743
35744         };
35745         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
35746         {
35747                 size_t get_index() const {return type;}
35748                 bool is_unknown() const { return type == 3; }
35749                 void clear() {type = 0;}
35750                 void select_id_ServedNRCellsToActivate() { set(mandatory); type=1;}
35751                 void select_id_ActivationID() { set(mandatory); type=2;}
35752                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
35753                 template<typename V>  bool decode(V& v)
35754                 {
35755                         clear();
35756                         if(!v(ref_nested())) return false;
35757                         if(equal(mandatory)) { type = 1; return true; }
35758                         else if(equal(mandatory)) { type = 2; return true; }
35759                         else { type = 3; return true;}
35760                         return false;
35761
35762                 }
35763                 template<typename V> bool encode(V& v) const
35764                 {
35765                         return v(ref_nested());
35766
35767                 }
35768                 protected:
35769                 template<typename V>  bool decode(size_t index, V& v)
35770                 {
35771                         clear();
35772                         switch(index)
35773                         {
35774                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
35775                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
35776                         case 3: type = 3; return v(ref_nested());
35777                         ref_nested().clear();
35778                         }
35779                         return false;
35780
35781                 }
35782                 template<typename V> bool encode(size_t index, V& v) const
35783                 {
35784                         if(index != type) {return false;} return v(ref_nested());
35785
35786                 }
35787                 private:
35788                 size_t type {0};
35789
35790         };
35791
35792 };
35793 /*
35794 ENDCCellActivationRequest ::= SEQUENCE {
35795         protocolIEs             ProtocolIE-Container    {{ENDCCellActivationRequest-IEs}},
35796         ...
35797 }
35798 */
35799
35800 struct ENDCCellActivationRequest : asn::sequence<1, 0, true, 0>
35801 {
35802         static constexpr const char* name() {return "ENDCCellActivationRequest";}
35803         using parent_t = asn::sequence<1, 0, true, 0>;
35804         struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationRequest_IEs>
35805         {
35806                 static constexpr const char* name() {return "protocolIEs_t";}
35807                 using parent_t = ProtocolIE_Container<ENDCCellActivationRequest_IEs>;
35808
35809         };
35810         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
35811         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
35812         template<typename V> void decode(V& v)
35813         {
35814                 v(protocolIEs);
35815
35816         };
35817         template<typename V> void encode(V& v) const
35818         {
35819                 v(protocolIEs);
35820
35821         };
35822         void clear()
35823         {
35824                 protocolIEs.clear();
35825
35826         };
35827         private:
35828         protocolIEs_t   protocolIEs;
35829
35830 };
35831 /*
35832 ENDCCellActivationResponse-IEs X2AP-PROTOCOL-IES ::= {
35833         { ID id-ActivatedNRCellList             CRITICALITY ignore      TYPE ActivatedNRCellList                                PRESENCE mandatory}|
35834         { ID id-ActivationID                            CRITICALITY reject      TYPE ActivationID                                       PRESENCE mandatory}|
35835         { ID id-CriticalityDiagnostics  CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional},
35836         ...
35837 }
35838 */
35839
35840 struct ENDCCellActivationResponse_IEs
35841 {
35842         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
35843         {
35844                 size_t get_index() const {return type;}
35845                 bool is_unknown() const { return type == 4; }
35846                 void clear() {type = 0;}
35847                 void select_id_ActivatedNRCellList() { set(id_ActivatedNRCellList); type=1;}
35848                 void select_id_ActivationID() { set(id_ActivationID); type=2;}
35849                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
35850                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
35851                 template<typename V>  bool decode(V& v)
35852                 {
35853                         clear();
35854                         if(!v(ref_nested())) return false;
35855                         if(equal(id_ActivatedNRCellList)) { type = 1; return true; }
35856                         else if(equal(id_ActivationID)) { type = 2; return true; }
35857                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
35858                         else { type = 4; return true;}
35859                         return false;
35860
35861                 }
35862                 template<typename V> bool encode(V& v) const
35863                 {
35864                         return v(ref_nested());
35865
35866                 }
35867                 protected:
35868                 template<typename V>  bool decode(size_t index, V& v)
35869                 {
35870                         clear();
35871                         switch(index)
35872                         {
35873                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ActivatedNRCellList);} return false;
35874                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ActivationID);} return false;
35875                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
35876                         case 4: type = 4; return v(ref_nested());
35877                         ref_nested().clear();
35878                         }
35879                         return false;
35880
35881                 }
35882                 template<typename V> bool encode(size_t index, V& v) const
35883                 {
35884                         if(index != type) {return false;} return v(ref_nested());
35885
35886                 }
35887                 private:
35888                 size_t type {0};
35889
35890         };
35891         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
35892         {
35893                 size_t get_index() const {return type;}
35894                 bool is_unknown() const { return type == 4; }
35895                 void clear() {type = 0;}
35896                 void select_id_ActivatedNRCellList() { set(ignore); type=1;}
35897                 void select_id_ActivationID() { set(reject); type=2;}
35898                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
35899                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
35900                 template<typename V>  bool decode(V& v)
35901                 {
35902                         clear();
35903                         if(!v(ref_nested())) return false;
35904                         if(equal(ignore)) { type = 1; return true; }
35905                         else if(equal(reject)) { type = 2; return true; }
35906                         else if(equal(ignore)) { type = 3; return true; }
35907                         else { type = 4; return true;}
35908                         return false;
35909
35910                 }
35911                 template<typename V> bool encode(V& v) const
35912                 {
35913                         return v(ref_nested());
35914
35915                 }
35916                 protected:
35917                 template<typename V>  bool decode(size_t index, V& v)
35918                 {
35919                         clear();
35920                         switch(index)
35921                         {
35922                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
35923                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
35924                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
35925                         case 4: type = 4; return v(ref_nested());
35926                         ref_nested().clear();
35927                         }
35928                         return false;
35929
35930                 }
35931                 template<typename V> bool encode(size_t index, V& v) const
35932                 {
35933                         if(index != type) {return false;} return v(ref_nested());
35934
35935                 }
35936                 private:
35937                 size_t type {0};
35938
35939         };
35940         struct Value_t : asn::typefield<true>
35941         {
35942                 ~Value_t()      {clear();}
35943                 size_t get_index() const {return type;}
35944                 ActivatedNRCellList& select_id_ActivatedNRCellList() { return set<ActivatedNRCellList>(1); }
35945                 ActivatedNRCellList const* get_id_ActivatedNRCellList() const { return get<ActivatedNRCellList>(1); }
35946                 ActivationID& select_id_ActivationID() { return set<ActivationID>(2); }
35947                 ActivationID const* get_id_ActivationID() const { return get<ActivationID>(2); }
35948                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
35949                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
35950                 bool is_unknown() const { return type == 4; }
35951                 void clear()
35952                 {
35953                         switch(type)
35954                         {
35955                         case 1: var.destroy<ActivatedNRCellList>(); break;
35956                         case 2: var.destroy<ActivationID>(); break;
35957                         case 3: var.destroy<CriticalityDiagnostics>(); break;
35958                         }
35959                         type = 0; ref_nested().clear();
35960                 }
35961                 template<typename V> static inline void enumerate(V& v)
35962                 {
35963                         v.template operator()<ActivatedNRCellList>(1);
35964                         v.template operator()<ActivationID>(2);
35965                         v.template operator()<CriticalityDiagnostics>(3);
35966
35967                 }
35968                 protected:
35969                 template<typename V> bool decode(size_t index, V& v)
35970                 {
35971                         clear();
35972                         switch(index)
35973                         {
35974                         case 1: v(select_id_ActivatedNRCellList()); return true;
35975                         case 2: v(select_id_ActivationID()); return true;
35976                         case 3: v(select_id_CriticalityDiagnostics()); return true;
35977                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
35978                         }
35979                         return false;
35980
35981                 }
35982                 template<typename V> bool encode(size_t index, V& v) const
35983                 {
35984                         if(index != type) return false;
35985                         switch(type)
35986                         {
35987                         case 1: v(var.as<ActivatedNRCellList>()); return true;
35988                         case 2: v(var.as<ActivationID>()); return true;
35989                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
35990                         }
35991                         return false;
35992
35993                 }
35994                 private:
35995                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
35996                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
35997                 union union_type
35998                 {
35999                         char dummy1[sizeof(ActivatedNRCellList)];
36000                         char dummy2[sizeof(ActivationID)];
36001                         char dummy3[sizeof(CriticalityDiagnostics)];
36002
36003                 };
36004                 asn::variant<sizeof(union_type)> var;
36005                 size_t type {0};
36006
36007         };
36008         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
36009         {
36010                 size_t get_index() const {return type;}
36011                 bool is_unknown() const { return type == 4; }
36012                 void clear() {type = 0;}
36013                 void select_id_ActivatedNRCellList() { set(mandatory); type=1;}
36014                 void select_id_ActivationID() { set(mandatory); type=2;}
36015                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
36016                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
36017                 template<typename V>  bool decode(V& v)
36018                 {
36019                         clear();
36020                         if(!v(ref_nested())) return false;
36021                         if(equal(mandatory)) { type = 1; return true; }
36022                         else if(equal(mandatory)) { type = 2; return true; }
36023                         else if(equal(optional)) { type = 3; return true; }
36024                         else { type = 4; return true;}
36025                         return false;
36026
36027                 }
36028                 template<typename V> bool encode(V& v) const
36029                 {
36030                         return v(ref_nested());
36031
36032                 }
36033                 protected:
36034                 template<typename V>  bool decode(size_t index, V& v)
36035                 {
36036                         clear();
36037                         switch(index)
36038                         {
36039                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
36040                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
36041                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
36042                         case 4: type = 4; return v(ref_nested());
36043                         ref_nested().clear();
36044                         }
36045                         return false;
36046
36047                 }
36048                 template<typename V> bool encode(size_t index, V& v) const
36049                 {
36050                         if(index != type) {return false;} return v(ref_nested());
36051
36052                 }
36053                 private:
36054                 size_t type {0};
36055
36056         };
36057
36058 };
36059 /*
36060 ENDCCellActivationResponse ::= SEQUENCE {
36061         protocolIEs             ProtocolIE-Container    {{ENDCCellActivationResponse-IEs}},
36062         ...
36063 }
36064 */
36065
36066 struct ENDCCellActivationResponse : asn::sequence<1, 0, true, 0>
36067 {
36068         static constexpr const char* name() {return "ENDCCellActivationResponse";}
36069         using parent_t = asn::sequence<1, 0, true, 0>;
36070         struct protocolIEs_t : ProtocolIE_Container<ENDCCellActivationResponse_IEs>
36071         {
36072                 static constexpr const char* name() {return "protocolIEs_t";}
36073                 using parent_t = ProtocolIE_Container<ENDCCellActivationResponse_IEs>;
36074
36075         };
36076         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
36077         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
36078         template<typename V> void decode(V& v)
36079         {
36080                 v(protocolIEs);
36081
36082         };
36083         template<typename V> void encode(V& v) const
36084         {
36085                 v(protocolIEs);
36086
36087         };
36088         void clear()
36089         {
36090                 protocolIEs.clear();
36091
36092         };
36093         private:
36094         protocolIEs_t   protocolIEs;
36095
36096 };
36097 /*
36098 FDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36099         ...
36100 }
36101 */
36102
36103 struct FDD_InfoServedNRCell_Information_ExtIEs
36104 {
36105         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36106         {
36107                 size_t get_index() const {return type;}
36108                 bool is_unknown() const { return type == 1; }
36109                 void clear() {type = 0;}
36110                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36111                 template<typename V>  bool decode(V& v)
36112                 {
36113                         clear();
36114                         if(!v(ref_nested())) return false;
36115                         { type = 1; return true;}
36116                         return false;
36117
36118                 }
36119                 template<typename V> bool encode(V& v) const
36120                 {
36121                         return v(ref_nested());
36122
36123                 }
36124                 protected:
36125                 template<typename V>  bool decode(size_t index, V& v)
36126                 {
36127                         clear();
36128                         switch(index)
36129                         {
36130                         case 1: type = 1; return v(ref_nested());
36131                         ref_nested().clear();
36132                         }
36133                         return false;
36134
36135                 }
36136                 template<typename V> bool encode(size_t index, V& v) const
36137                 {
36138                         if(index != type) {return false;} return v(ref_nested());
36139
36140                 }
36141                 private:
36142                 size_t type {0};
36143
36144         };
36145         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36146         {
36147                 size_t get_index() const {return type;}
36148                 bool is_unknown() const { return type == 1; }
36149                 void clear() {type = 0;}
36150                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36151                 template<typename V>  bool decode(V& v)
36152                 {
36153                         clear();
36154                         if(!v(ref_nested())) return false;
36155                         { type = 1; return true;}
36156                         return false;
36157
36158                 }
36159                 template<typename V> bool encode(V& v) const
36160                 {
36161                         return v(ref_nested());
36162
36163                 }
36164                 protected:
36165                 template<typename V>  bool decode(size_t index, V& v)
36166                 {
36167                         clear();
36168                         switch(index)
36169                         {
36170                         case 1: type = 1; return v(ref_nested());
36171                         ref_nested().clear();
36172                         }
36173                         return false;
36174
36175                 }
36176                 template<typename V> bool encode(size_t index, V& v) const
36177                 {
36178                         if(index != type) {return false;} return v(ref_nested());
36179
36180                 }
36181                 private:
36182                 size_t type {0};
36183
36184         };
36185         struct Extension_t : asn::typefield<true>
36186         {
36187                 ~Extension_t()  {clear();}
36188                 size_t get_index() const {return type;}
36189                 bool is_unknown() const { return type == 1; }
36190                 void clear()
36191                 {
36192                         type = 0; ref_nested().clear();
36193                 }
36194                 template<typename V> static inline void enumerate(V& v)
36195                 {
36196
36197                 }
36198                 protected:
36199                 template<typename V> bool decode(size_t index, V& v)
36200                 {
36201                         clear();
36202                         switch(index)
36203                         {
36204                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36205                         }
36206                         return false;
36207
36208                 }
36209                 template<typename V> bool encode(size_t index, V& v) const
36210                 {
36211                         if(index != type) return false;
36212                         return false;
36213
36214                 }
36215                 private:
36216                 size_t type {0};
36217
36218         };
36219         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36220         {
36221                 size_t get_index() const {return type;}
36222                 bool is_unknown() const { return type == 1; }
36223                 void clear() {type = 0;}
36224                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36225                 template<typename V>  bool decode(V& v)
36226                 {
36227                         clear();
36228                         if(!v(ref_nested())) return false;
36229                         { type = 1; return true;}
36230                         return false;
36231
36232                 }
36233                 template<typename V> bool encode(V& v) const
36234                 {
36235                         return v(ref_nested());
36236
36237                 }
36238                 protected:
36239                 template<typename V>  bool decode(size_t index, V& v)
36240                 {
36241                         clear();
36242                         switch(index)
36243                         {
36244                         case 1: type = 1; return v(ref_nested());
36245                         ref_nested().clear();
36246                         }
36247                         return false;
36248
36249                 }
36250                 template<typename V> bool encode(size_t index, V& v) const
36251                 {
36252                         if(index != type) {return false;} return v(ref_nested());
36253
36254                 }
36255                 private:
36256                 size_t type {0};
36257
36258         };
36259
36260 };
36261 /*
36262 FDD-InfoServedNRCell-Information ::= SEQUENCE {
36263         ul-NRFreqInfo                           NRFreqInfo,
36264         dl-NRFreqInfo                           NRFreqInfo,
36265         ul-NR-TxBW                              NR-TxBW,
36266         dl-NR-TxBW                              NR-TxBW,
36267         iE-Extensions                   ProtocolExtensionContainer { {FDD-InfoServedNRCell-Information-ExtIEs} }                OPTIONAL,
36268         ...
36269 }
36270 */
36271
36272 struct FDD_InfoServedNRCell_Information : asn::sequence<5, 0, true, 1>
36273 {
36274         static constexpr const char* name() {return "FDD-InfoServedNRCell-Information";}
36275         using parent_t = asn::sequence<5, 0, true, 1>;
36276         struct ul_NRFreqInfo_t : NRFreqInfo
36277         {
36278                 static constexpr const char* name() {return "ul_NRFreqInfo_t";}
36279                 using parent_t = NRFreqInfo;
36280
36281         };
36282         ul_NRFreqInfo_t& ref_ul_NRFreqInfo() {return ul_NRFreqInfo;}
36283         ul_NRFreqInfo_t const& ref_ul_NRFreqInfo() const {return ul_NRFreqInfo;}
36284         struct dl_NRFreqInfo_t : NRFreqInfo
36285         {
36286                 static constexpr const char* name() {return "dl_NRFreqInfo_t";}
36287                 using parent_t = NRFreqInfo;
36288
36289         };
36290         dl_NRFreqInfo_t& ref_dl_NRFreqInfo() {return dl_NRFreqInfo;}
36291         dl_NRFreqInfo_t const& ref_dl_NRFreqInfo() const {return dl_NRFreqInfo;}
36292         struct ul_NR_TxBW_t : NR_TxBW
36293         {
36294                 static constexpr const char* name() {return "ul_NR_TxBW_t";}
36295                 using parent_t = NR_TxBW;
36296
36297         };
36298         ul_NR_TxBW_t& ref_ul_NR_TxBW() {return ul_NR_TxBW;}
36299         ul_NR_TxBW_t const& ref_ul_NR_TxBW() const {return ul_NR_TxBW;}
36300         struct dl_NR_TxBW_t : NR_TxBW
36301         {
36302                 static constexpr const char* name() {return "dl_NR_TxBW_t";}
36303                 using parent_t = NR_TxBW;
36304
36305         };
36306         dl_NR_TxBW_t& ref_dl_NR_TxBW() {return dl_NR_TxBW;}
36307         dl_NR_TxBW_t const& ref_dl_NR_TxBW() const {return dl_NR_TxBW;}
36308         struct iE_Extensions_t : ProtocolExtensionContainer<FDD_InfoServedNRCell_Information_ExtIEs>
36309         {
36310                 static constexpr const char* name() {return "iE_Extensions_t";}
36311                 using parent_t = ProtocolExtensionContainer<FDD_InfoServedNRCell_Information_ExtIEs>;
36312                 static constexpr bool optional = true;
36313
36314         };
36315         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36316         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36317         template<typename V> void decode(V& v)
36318         {
36319                 v(ul_NRFreqInfo);
36320                 v(dl_NRFreqInfo);
36321                 v(ul_NR_TxBW);
36322                 v(dl_NR_TxBW);
36323                 v(iE_Extensions);
36324
36325         };
36326         template<typename V> void encode(V& v) const
36327         {
36328                 v(ul_NRFreqInfo);
36329                 v(dl_NRFreqInfo);
36330                 v(ul_NR_TxBW);
36331                 v(dl_NR_TxBW);
36332                 v(iE_Extensions);
36333
36334         };
36335         void clear()
36336         {
36337                 ul_NRFreqInfo.clear();
36338                 dl_NRFreqInfo.clear();
36339                 ul_NR_TxBW.clear();
36340                 dl_NR_TxBW.clear();
36341                 iE_Extensions.clear();
36342
36343         };
36344         private:
36345         ul_NRFreqInfo_t ul_NRFreqInfo;
36346         dl_NRFreqInfo_t dl_NRFreqInfo;
36347         ul_NR_TxBW_t    ul_NR_TxBW;
36348         dl_NR_TxBW_t    dl_NR_TxBW;
36349         iE_Extensions_t iE_Extensions;
36350
36351 };
36352 /*
36353 TDD-InfoServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36354         ...
36355 }
36356 */
36357
36358 struct TDD_InfoServedNRCell_Information_ExtIEs
36359 {
36360         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36361         {
36362                 size_t get_index() const {return type;}
36363                 bool is_unknown() const { return type == 1; }
36364                 void clear() {type = 0;}
36365                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36366                 template<typename V>  bool decode(V& v)
36367                 {
36368                         clear();
36369                         if(!v(ref_nested())) return false;
36370                         { type = 1; return true;}
36371                         return false;
36372
36373                 }
36374                 template<typename V> bool encode(V& v) const
36375                 {
36376                         return v(ref_nested());
36377
36378                 }
36379                 protected:
36380                 template<typename V>  bool decode(size_t index, V& v)
36381                 {
36382                         clear();
36383                         switch(index)
36384                         {
36385                         case 1: type = 1; return v(ref_nested());
36386                         ref_nested().clear();
36387                         }
36388                         return false;
36389
36390                 }
36391                 template<typename V> bool encode(size_t index, V& v) const
36392                 {
36393                         if(index != type) {return false;} return v(ref_nested());
36394
36395                 }
36396                 private:
36397                 size_t type {0};
36398
36399         };
36400         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36401         {
36402                 size_t get_index() const {return type;}
36403                 bool is_unknown() const { return type == 1; }
36404                 void clear() {type = 0;}
36405                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36406                 template<typename V>  bool decode(V& v)
36407                 {
36408                         clear();
36409                         if(!v(ref_nested())) return false;
36410                         { type = 1; return true;}
36411                         return false;
36412
36413                 }
36414                 template<typename V> bool encode(V& v) const
36415                 {
36416                         return v(ref_nested());
36417
36418                 }
36419                 protected:
36420                 template<typename V>  bool decode(size_t index, V& v)
36421                 {
36422                         clear();
36423                         switch(index)
36424                         {
36425                         case 1: type = 1; return v(ref_nested());
36426                         ref_nested().clear();
36427                         }
36428                         return false;
36429
36430                 }
36431                 template<typename V> bool encode(size_t index, V& v) const
36432                 {
36433                         if(index != type) {return false;} return v(ref_nested());
36434
36435                 }
36436                 private:
36437                 size_t type {0};
36438
36439         };
36440         struct Extension_t : asn::typefield<true>
36441         {
36442                 ~Extension_t()  {clear();}
36443                 size_t get_index() const {return type;}
36444                 bool is_unknown() const { return type == 1; }
36445                 void clear()
36446                 {
36447                         type = 0; ref_nested().clear();
36448                 }
36449                 template<typename V> static inline void enumerate(V& v)
36450                 {
36451
36452                 }
36453                 protected:
36454                 template<typename V> bool decode(size_t index, V& v)
36455                 {
36456                         clear();
36457                         switch(index)
36458                         {
36459                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36460                         }
36461                         return false;
36462
36463                 }
36464                 template<typename V> bool encode(size_t index, V& v) const
36465                 {
36466                         if(index != type) return false;
36467                         return false;
36468
36469                 }
36470                 private:
36471                 size_t type {0};
36472
36473         };
36474         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36475         {
36476                 size_t get_index() const {return type;}
36477                 bool is_unknown() const { return type == 1; }
36478                 void clear() {type = 0;}
36479                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36480                 template<typename V>  bool decode(V& v)
36481                 {
36482                         clear();
36483                         if(!v(ref_nested())) return false;
36484                         { type = 1; return true;}
36485                         return false;
36486
36487                 }
36488                 template<typename V> bool encode(V& v) const
36489                 {
36490                         return v(ref_nested());
36491
36492                 }
36493                 protected:
36494                 template<typename V>  bool decode(size_t index, V& v)
36495                 {
36496                         clear();
36497                         switch(index)
36498                         {
36499                         case 1: type = 1; return v(ref_nested());
36500                         ref_nested().clear();
36501                         }
36502                         return false;
36503
36504                 }
36505                 template<typename V> bool encode(size_t index, V& v) const
36506                 {
36507                         if(index != type) {return false;} return v(ref_nested());
36508
36509                 }
36510                 private:
36511                 size_t type {0};
36512
36513         };
36514
36515 };
36516 /*
36517 TDD-InfoServedNRCell-Information ::= SEQUENCE {
36518         nRFreqInfo                              NRFreqInfo,
36519         nR-TxBW                                 NR-TxBW,
36520         iE-Extensions                   ProtocolExtensionContainer { {TDD-InfoServedNRCell-Information-ExtIEs} }                OPTIONAL,
36521         ...
36522 }
36523 */
36524
36525 struct TDD_InfoServedNRCell_Information : asn::sequence<3, 0, true, 1>
36526 {
36527         static constexpr const char* name() {return "TDD-InfoServedNRCell-Information";}
36528         using parent_t = asn::sequence<3, 0, true, 1>;
36529         struct nRFreqInfo_t : NRFreqInfo
36530         {
36531                 static constexpr const char* name() {return "nRFreqInfo_t";}
36532                 using parent_t = NRFreqInfo;
36533
36534         };
36535         nRFreqInfo_t& ref_nRFreqInfo() {return nRFreqInfo;}
36536         nRFreqInfo_t const& ref_nRFreqInfo() const {return nRFreqInfo;}
36537         struct nR_TxBW_t : NR_TxBW
36538         {
36539                 static constexpr const char* name() {return "nR_TxBW_t";}
36540                 using parent_t = NR_TxBW;
36541
36542         };
36543         nR_TxBW_t& ref_nR_TxBW() {return nR_TxBW;}
36544         nR_TxBW_t const& ref_nR_TxBW() const {return nR_TxBW;}
36545         struct iE_Extensions_t : ProtocolExtensionContainer<TDD_InfoServedNRCell_Information_ExtIEs>
36546         {
36547                 static constexpr const char* name() {return "iE_Extensions_t";}
36548                 using parent_t = ProtocolExtensionContainer<TDD_InfoServedNRCell_Information_ExtIEs>;
36549                 static constexpr bool optional = true;
36550
36551         };
36552         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36553         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36554         template<typename V> void decode(V& v)
36555         {
36556                 v(nRFreqInfo);
36557                 v(nR_TxBW);
36558                 v(iE_Extensions);
36559
36560         };
36561         template<typename V> void encode(V& v) const
36562         {
36563                 v(nRFreqInfo);
36564                 v(nR_TxBW);
36565                 v(iE_Extensions);
36566
36567         };
36568         void clear()
36569         {
36570                 nRFreqInfo.clear();
36571                 nR_TxBW.clear();
36572                 iE_Extensions.clear();
36573
36574         };
36575         private:
36576         nRFreqInfo_t    nRFreqInfo;
36577         nR_TxBW_t       nR_TxBW;
36578         iE_Extensions_t iE_Extensions;
36579
36580 };
36581 /*
36582 ServedNRCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36583         ...
36584 }
36585 */
36586
36587 struct ServedNRCell_Information_ExtIEs
36588 {
36589         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36590         {
36591                 size_t get_index() const {return type;}
36592                 bool is_unknown() const { return type == 1; }
36593                 void clear() {type = 0;}
36594                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36595                 template<typename V>  bool decode(V& v)
36596                 {
36597                         clear();
36598                         if(!v(ref_nested())) return false;
36599                         { type = 1; return true;}
36600                         return false;
36601
36602                 }
36603                 template<typename V> bool encode(V& v) const
36604                 {
36605                         return v(ref_nested());
36606
36607                 }
36608                 protected:
36609                 template<typename V>  bool decode(size_t index, V& v)
36610                 {
36611                         clear();
36612                         switch(index)
36613                         {
36614                         case 1: type = 1; return v(ref_nested());
36615                         ref_nested().clear();
36616                         }
36617                         return false;
36618
36619                 }
36620                 template<typename V> bool encode(size_t index, V& v) const
36621                 {
36622                         if(index != type) {return false;} return v(ref_nested());
36623
36624                 }
36625                 private:
36626                 size_t type {0};
36627
36628         };
36629         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36630         {
36631                 size_t get_index() const {return type;}
36632                 bool is_unknown() const { return type == 1; }
36633                 void clear() {type = 0;}
36634                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
36635                 template<typename V>  bool decode(V& v)
36636                 {
36637                         clear();
36638                         if(!v(ref_nested())) return false;
36639                         { type = 1; return true;}
36640                         return false;
36641
36642                 }
36643                 template<typename V> bool encode(V& v) const
36644                 {
36645                         return v(ref_nested());
36646
36647                 }
36648                 protected:
36649                 template<typename V>  bool decode(size_t index, V& v)
36650                 {
36651                         clear();
36652                         switch(index)
36653                         {
36654                         case 1: type = 1; return v(ref_nested());
36655                         ref_nested().clear();
36656                         }
36657                         return false;
36658
36659                 }
36660                 template<typename V> bool encode(size_t index, V& v) const
36661                 {
36662                         if(index != type) {return false;} return v(ref_nested());
36663
36664                 }
36665                 private:
36666                 size_t type {0};
36667
36668         };
36669         struct Extension_t : asn::typefield<true>
36670         {
36671                 ~Extension_t()  {clear();}
36672                 size_t get_index() const {return type;}
36673                 bool is_unknown() const { return type == 1; }
36674                 void clear()
36675                 {
36676                         type = 0; ref_nested().clear();
36677                 }
36678                 template<typename V> static inline void enumerate(V& v)
36679                 {
36680
36681                 }
36682                 protected:
36683                 template<typename V> bool decode(size_t index, V& v)
36684                 {
36685                         clear();
36686                         switch(index)
36687                         {
36688                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
36689                         }
36690                         return false;
36691
36692                 }
36693                 template<typename V> bool encode(size_t index, V& v) const
36694                 {
36695                         if(index != type) return false;
36696                         return false;
36697
36698                 }
36699                 private:
36700                 size_t type {0};
36701
36702         };
36703         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
36704         {
36705                 size_t get_index() const {return type;}
36706                 bool is_unknown() const { return type == 1; }
36707                 void clear() {type = 0;}
36708                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
36709                 template<typename V>  bool decode(V& v)
36710                 {
36711                         clear();
36712                         if(!v(ref_nested())) return false;
36713                         { type = 1; return true;}
36714                         return false;
36715
36716                 }
36717                 template<typename V> bool encode(V& v) const
36718                 {
36719                         return v(ref_nested());
36720
36721                 }
36722                 protected:
36723                 template<typename V>  bool decode(size_t index, V& v)
36724                 {
36725                         clear();
36726                         switch(index)
36727                         {
36728                         case 1: type = 1; return v(ref_nested());
36729                         ref_nested().clear();
36730                         }
36731                         return false;
36732
36733                 }
36734                 template<typename V> bool encode(size_t index, V& v) const
36735                 {
36736                         if(index != type) {return false;} return v(ref_nested());
36737
36738                 }
36739                 private:
36740                 size_t type {0};
36741
36742         };
36743
36744 };
36745 /*
36746 ServedNRCell-Information ::= SEQUENCE {
36747         nrpCI                           NRPCI,
36748         nrCellID                        NRCGI,
36749         fiveGS-TAC                      FiveGS-TAC      OPTIONAL,
36750         configured-TAC          TAC                     OPTIONAL,
36751         broadcastPLMNs          BroadcastPLMNs-Item,
36752         nrModeInfo                      CHOICE {
36753                 fdd             FDD-InfoServedNRCell-Information,
36754                 tdd             TDD-InfoServedNRCell-Information,
36755                 ...
36756         },
36757         measurementTimingConfiguration  OCTET STRING,
36758         iE-Extensions                                           ProtocolExtensionContainer { {ServedNRCell-Information-ExtIEs} } OPTIONAL,
36759         ...
36760 }
36761 */
36762
36763 struct ServedNRCell_Information : asn::sequence<8, 0, true, 3>
36764 {
36765         static constexpr const char* name() {return "ServedNRCell-Information";}
36766         using parent_t = asn::sequence<8, 0, true, 3>;
36767         struct nrpCI_t : NRPCI
36768         {
36769                 static constexpr const char* name() {return "nrpCI_t";}
36770                 using parent_t = NRPCI;
36771
36772         };
36773         nrpCI_t& ref_nrpCI() {return nrpCI;}
36774         nrpCI_t const& ref_nrpCI() const {return nrpCI;}
36775         struct nrCellID_t : NRCGI
36776         {
36777                 static constexpr const char* name() {return "nrCellID_t";}
36778                 using parent_t = NRCGI;
36779
36780         };
36781         nrCellID_t& ref_nrCellID() {return nrCellID;}
36782         nrCellID_t const& ref_nrCellID() const {return nrCellID;}
36783         struct fiveGS_TAC_t : FiveGS_TAC
36784         {
36785                 static constexpr const char* name() {return "fiveGS_TAC_t";}
36786                 using parent_t = FiveGS_TAC;
36787                 static constexpr bool optional = true;
36788
36789         };
36790         fiveGS_TAC_t& set_fiveGS_TAC() { fiveGS_TAC.setpresent(true); return fiveGS_TAC;}
36791         fiveGS_TAC_t const* get_fiveGS_TAC() const {return fiveGS_TAC.is_valid() ? &fiveGS_TAC : nullptr;}
36792         struct configured_TAC_t : TAC
36793         {
36794                 static constexpr const char* name() {return "configured_TAC_t";}
36795                 using parent_t = TAC;
36796                 static constexpr bool optional = true;
36797
36798         };
36799         configured_TAC_t& set_configured_TAC() { configured_TAC.setpresent(true); return configured_TAC;}
36800         configured_TAC_t const* get_configured_TAC() const {return configured_TAC.is_valid() ? &configured_TAC : nullptr;}
36801         struct broadcastPLMNs_t : BroadcastPLMNs_Item
36802         {
36803                 static constexpr const char* name() {return "broadcastPLMNs_t";}
36804                 using parent_t = BroadcastPLMNs_Item;
36805
36806         };
36807         broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
36808         broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
36809         struct nrModeInfo_t : asn::choice<2, 0, true>
36810         {
36811                 static constexpr const char* name() {return "nrModeInfo_t";}
36812                 using parent_t = asn::choice<2, 0, true>;
36813                 index_type get_index() const {return index;}
36814                 bool is_unknown() const {return index == 3;}
36815                 void set_unknown() { set_index(3);  }
36816                 ~nrModeInfo_t() {clear();}
36817                 struct fdd_t : FDD_InfoServedNRCell_Information
36818                 {
36819                         static constexpr const char* name() {return "fdd_t";}
36820                         using parent_t = FDD_InfoServedNRCell_Information;
36821
36822                 };
36823                 struct tdd_t : TDD_InfoServedNRCell_Information
36824                 {
36825                         static constexpr const char* name() {return "tdd_t";}
36826                         using parent_t = TDD_InfoServedNRCell_Information;
36827
36828                 };
36829                 void clear()
36830                 {
36831                         switch(get_index())
36832                         {
36833                         case 1: var.destroy<fdd_t>(); break;
36834                         case 2: var.destroy<tdd_t>(); break;
36835                         }
36836                         index = 0;
36837                         base::clear();
36838                 }
36839                 template<typename V> bool decode(size_t idx, V& v)
36840                 {
36841                         clear();
36842                         switch(idx)
36843                         {
36844                         case 1: set_index(1); return v(var.build<fdd_t>());
36845                         case 2: set_index(2); return v(var.build<tdd_t>());
36846                         }
36847                         return false;
36848
36849                 }
36850                 template<typename V> bool encode(V& v) const
36851                 {
36852                         switch(get_index())
36853                         {
36854                         case 1: return v(var.as<fdd_t>());
36855                         case 2: return v(var.as<tdd_t>());
36856                         }
36857                         return false;
36858                 }
36859                 template<typename V> static inline void enumerate(V& v)
36860                 {
36861                         v.template operator()<fdd_t>(1);
36862                         v.template operator()<tdd_t>(2);
36863
36864                 }
36865                 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
36866                 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
36867                 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
36868                 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
36869                 private:
36870                 void set_index(index_type i) {index = i; base::set();}
36871                 union union_type
36872                 {
36873                         char dummy1[sizeof(fdd_t)];
36874                         char dummy2[sizeof(tdd_t)];
36875
36876                 };
36877                 asn::variant<sizeof(union_type)>        var;
36878                 index_type      index {0};
36879         };
36880         nrModeInfo_t& ref_nrModeInfo() {return nrModeInfo;}
36881         nrModeInfo_t const& ref_nrModeInfo() const {return nrModeInfo;}
36882         struct measurementTimingConfiguration_t : asn::ostring<>
36883         {
36884                 static constexpr const char* name() {return "measurementTimingConfiguration_t";}
36885                 using parent_t = asn::ostring<>;
36886
36887         };
36888
36889         measurementTimingConfiguration_t& ref_measurementTimingConfiguration() {return measurementTimingConfiguration;}
36890         measurementTimingConfiguration_t const& ref_measurementTimingConfiguration() const {return measurementTimingConfiguration;}
36891         struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCell_Information_ExtIEs>
36892         {
36893                 static constexpr const char* name() {return "iE_Extensions_t";}
36894                 using parent_t = ProtocolExtensionContainer<ServedNRCell_Information_ExtIEs>;
36895                 static constexpr bool optional = true;
36896
36897         };
36898         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
36899         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
36900         template<typename V> void decode(V& v)
36901         {
36902                 v(nrpCI);
36903                 v(nrCellID);
36904                 v(fiveGS_TAC);
36905                 v(configured_TAC);
36906                 v(broadcastPLMNs);
36907                 v(nrModeInfo);
36908                 v(measurementTimingConfiguration);
36909                 v(iE_Extensions);
36910
36911         };
36912         template<typename V> void encode(V& v) const
36913         {
36914                 v(nrpCI);
36915                 v(nrCellID);
36916                 v(fiveGS_TAC);
36917                 v(configured_TAC);
36918                 v(broadcastPLMNs);
36919                 v(nrModeInfo);
36920                 v(measurementTimingConfiguration);
36921                 v(iE_Extensions);
36922
36923         };
36924         void clear()
36925         {
36926                 nrpCI.clear();
36927                 nrCellID.clear();
36928                 fiveGS_TAC.clear();
36929                 configured_TAC.clear();
36930                 broadcastPLMNs.clear();
36931                 nrModeInfo.clear();
36932                 measurementTimingConfiguration.clear();
36933                 iE_Extensions.clear();
36934
36935         };
36936         private:
36937         nrpCI_t nrpCI;
36938         nrCellID_t      nrCellID;
36939         fiveGS_TAC_t    fiveGS_TAC;
36940         configured_TAC_t        configured_TAC;
36941         broadcastPLMNs_t        broadcastPLMNs;
36942         nrModeInfo_t    nrModeInfo;
36943         measurementTimingConfiguration_t        measurementTimingConfiguration;
36944         iE_Extensions_t iE_Extensions;
36945
36946 };
36947 /*
36948 En-gNBServedCells-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
36949         ...
36950 }
36951 */
36952
36953 struct En_gNBServedCells_ExtIEs
36954 {
36955         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
36956         {
36957                 size_t get_index() const {return type;}
36958                 bool is_unknown() const { return type == 1; }
36959                 void clear() {type = 0;}
36960                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
36961                 template<typename V>  bool decode(V& v)
36962                 {
36963                         clear();
36964                         if(!v(ref_nested())) return false;
36965                         { type = 1; return true;}
36966                         return false;
36967
36968                 }
36969                 template<typename V> bool encode(V& v) const
36970                 {
36971                         return v(ref_nested());
36972
36973                 }
36974                 protected:
36975                 template<typename V>  bool decode(size_t index, V& v)
36976                 {
36977                         clear();
36978                         switch(index)
36979                         {
36980                         case 1: type = 1; return v(ref_nested());
36981                         ref_nested().clear();
36982                         }
36983                         return false;
36984
36985                 }
36986                 template<typename V> bool encode(size_t index, V& v) const
36987                 {
36988                         if(index != type) {return false;} return v(ref_nested());
36989
36990                 }
36991                 private:
36992                 size_t type {0};
36993
36994         };
36995         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
36996         {
36997                 size_t get_index() const {return type;}
36998                 bool is_unknown() const { return type == 1; }
36999                 void clear() {type = 0;}
37000                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
37001                 template<typename V>  bool decode(V& v)
37002                 {
37003                         clear();
37004                         if(!v(ref_nested())) return false;
37005                         { type = 1; return true;}
37006                         return false;
37007
37008                 }
37009                 template<typename V> bool encode(V& v) const
37010                 {
37011                         return v(ref_nested());
37012
37013                 }
37014                 protected:
37015                 template<typename V>  bool decode(size_t index, V& v)
37016                 {
37017                         clear();
37018                         switch(index)
37019                         {
37020                         case 1: type = 1; return v(ref_nested());
37021                         ref_nested().clear();
37022                         }
37023                         return false;
37024
37025                 }
37026                 template<typename V> bool encode(size_t index, V& v) const
37027                 {
37028                         if(index != type) {return false;} return v(ref_nested());
37029
37030                 }
37031                 private:
37032                 size_t type {0};
37033
37034         };
37035         struct Extension_t : asn::typefield<true>
37036         {
37037                 ~Extension_t()  {clear();}
37038                 size_t get_index() const {return type;}
37039                 bool is_unknown() const { return type == 1; }
37040                 void clear()
37041                 {
37042                         type = 0; ref_nested().clear();
37043                 }
37044                 template<typename V> static inline void enumerate(V& v)
37045                 {
37046
37047                 }
37048                 protected:
37049                 template<typename V> bool decode(size_t index, V& v)
37050                 {
37051                         clear();
37052                         switch(index)
37053                         {
37054                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
37055                         }
37056                         return false;
37057
37058                 }
37059                 template<typename V> bool encode(size_t index, V& v) const
37060                 {
37061                         if(index != type) return false;
37062                         return false;
37063
37064                 }
37065                 private:
37066                 size_t type {0};
37067
37068         };
37069         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
37070         {
37071                 size_t get_index() const {return type;}
37072                 bool is_unknown() const { return type == 1; }
37073                 void clear() {type = 0;}
37074                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
37075                 template<typename V>  bool decode(V& v)
37076                 {
37077                         clear();
37078                         if(!v(ref_nested())) return false;
37079                         { type = 1; return true;}
37080                         return false;
37081
37082                 }
37083                 template<typename V> bool encode(V& v) const
37084                 {
37085                         return v(ref_nested());
37086
37087                 }
37088                 protected:
37089                 template<typename V>  bool decode(size_t index, V& v)
37090                 {
37091                         clear();
37092                         switch(index)
37093                         {
37094                         case 1: type = 1; return v(ref_nested());
37095                         ref_nested().clear();
37096                         }
37097                         return false;
37098
37099                 }
37100                 template<typename V> bool encode(size_t index, V& v) const
37101                 {
37102                         if(index != type) {return false;} return v(ref_nested());
37103
37104                 }
37105                 private:
37106                 size_t type {0};
37107
37108         };
37109
37110 };
37111 /*
37112 ServedNRcellsENDCX2ManagementList ::= SEQUENCE (SIZE (1.. maxCellinengNB)) OF SEQUENCE {
37113         servedNRCellInfo                                                ServedNRCell-Information,
37114         nRNeighbourInfo                                         NRNeighbour-Information OPTIONAL,
37115         iE-Extensions                                           ProtocolExtensionContainer { {En-gNBServedCells-ExtIEs} } OPTIONAL,
37116         ...
37117 }
37118 */
37119
37120 struct ServedNRcellsENDCX2ManagementList_elm : asn::sequence<3, 0, true, 2>
37121 {
37122         static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList_elm";}
37123         using parent_t = asn::sequence<3, 0, true, 2>;
37124         struct servedNRCellInfo_t : ServedNRCell_Information
37125         {
37126                 static constexpr const char* name() {return "servedNRCellInfo_t";}
37127                 using parent_t = ServedNRCell_Information;
37128
37129         };
37130         servedNRCellInfo_t& ref_servedNRCellInfo() {return servedNRCellInfo;}
37131         servedNRCellInfo_t const& ref_servedNRCellInfo() const {return servedNRCellInfo;}
37132         struct nRNeighbourInfo_t : NRNeighbour_Information
37133         {
37134                 static constexpr const char* name() {return "nRNeighbourInfo_t";}
37135                 using parent_t = NRNeighbour_Information;
37136                 static constexpr bool optional = true;
37137
37138         };
37139         nRNeighbourInfo_t& set_nRNeighbourInfo() { nRNeighbourInfo.setpresent(true); return nRNeighbourInfo;}
37140         nRNeighbourInfo_t const* get_nRNeighbourInfo() const {return nRNeighbourInfo.is_valid() ? &nRNeighbourInfo : nullptr;}
37141         struct iE_Extensions_t : ProtocolExtensionContainer<En_gNBServedCells_ExtIEs>
37142         {
37143                 static constexpr const char* name() {return "iE_Extensions_t";}
37144                 using parent_t = ProtocolExtensionContainer<En_gNBServedCells_ExtIEs>;
37145                 static constexpr bool optional = true;
37146
37147         };
37148         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
37149         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
37150         template<typename V> void decode(V& v)
37151         {
37152                 v(servedNRCellInfo);
37153                 v(nRNeighbourInfo);
37154                 v(iE_Extensions);
37155
37156         };
37157         template<typename V> void encode(V& v) const
37158         {
37159                 v(servedNRCellInfo);
37160                 v(nRNeighbourInfo);
37161                 v(iE_Extensions);
37162
37163         };
37164         void clear()
37165         {
37166                 servedNRCellInfo.clear();
37167                 nRNeighbourInfo.clear();
37168                 iE_Extensions.clear();
37169
37170         };
37171         private:
37172         servedNRCellInfo_t      servedNRCellInfo;
37173         nRNeighbourInfo_t       nRNeighbourInfo;
37174         iE_Extensions_t iE_Extensions;
37175
37176 };
37177 struct ServedNRcellsENDCX2ManagementList : asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>
37178 {
37179         static constexpr const char* name() {return "ServedNRcellsENDCX2ManagementList";}
37180         using parent_t = asn::sequenceof<ServedNRcellsENDCX2ManagementList_elm>;
37181         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
37182
37183 };
37184 /*
37185 ServedNRCellsToModify-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
37186         ...
37187 }
37188 */
37189
37190 struct ServedNRCellsToModify_Item_ExtIEs
37191 {
37192         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
37193         {
37194                 size_t get_index() const {return type;}
37195                 bool is_unknown() const { return type == 1; }
37196                 void clear() {type = 0;}
37197                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
37198                 template<typename V>  bool decode(V& v)
37199                 {
37200                         clear();
37201                         if(!v(ref_nested())) return false;
37202                         { type = 1; return true;}
37203                         return false;
37204
37205                 }
37206                 template<typename V> bool encode(V& v) const
37207                 {
37208                         return v(ref_nested());
37209
37210                 }
37211                 protected:
37212                 template<typename V>  bool decode(size_t index, V& v)
37213                 {
37214                         clear();
37215                         switch(index)
37216                         {
37217                         case 1: type = 1; return v(ref_nested());
37218                         ref_nested().clear();
37219                         }
37220                         return false;
37221
37222                 }
37223                 template<typename V> bool encode(size_t index, V& v) const
37224                 {
37225                         if(index != type) {return false;} return v(ref_nested());
37226
37227                 }
37228                 private:
37229                 size_t type {0};
37230
37231         };
37232         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
37233         {
37234                 size_t get_index() const {return type;}
37235                 bool is_unknown() const { return type == 1; }
37236                 void clear() {type = 0;}
37237                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
37238                 template<typename V>  bool decode(V& v)
37239                 {
37240                         clear();
37241                         if(!v(ref_nested())) return false;
37242                         { type = 1; return true;}
37243                         return false;
37244
37245                 }
37246                 template<typename V> bool encode(V& v) const
37247                 {
37248                         return v(ref_nested());
37249
37250                 }
37251                 protected:
37252                 template<typename V>  bool decode(size_t index, V& v)
37253                 {
37254                         clear();
37255                         switch(index)
37256                         {
37257                         case 1: type = 1; return v(ref_nested());
37258                         ref_nested().clear();
37259                         }
37260                         return false;
37261
37262                 }
37263                 template<typename V> bool encode(size_t index, V& v) const
37264                 {
37265                         if(index != type) {return false;} return v(ref_nested());
37266
37267                 }
37268                 private:
37269                 size_t type {0};
37270
37271         };
37272         struct Extension_t : asn::typefield<true>
37273         {
37274                 ~Extension_t()  {clear();}
37275                 size_t get_index() const {return type;}
37276                 bool is_unknown() const { return type == 1; }
37277                 void clear()
37278                 {
37279                         type = 0; ref_nested().clear();
37280                 }
37281                 template<typename V> static inline void enumerate(V& v)
37282                 {
37283
37284                 }
37285                 protected:
37286                 template<typename V> bool decode(size_t index, V& v)
37287                 {
37288                         clear();
37289                         switch(index)
37290                         {
37291                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
37292                         }
37293                         return false;
37294
37295                 }
37296                 template<typename V> bool encode(size_t index, V& v) const
37297                 {
37298                         if(index != type) return false;
37299                         return false;
37300
37301                 }
37302                 private:
37303                 size_t type {0};
37304
37305         };
37306         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
37307         {
37308                 size_t get_index() const {return type;}
37309                 bool is_unknown() const { return type == 1; }
37310                 void clear() {type = 0;}
37311                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
37312                 template<typename V>  bool decode(V& v)
37313                 {
37314                         clear();
37315                         if(!v(ref_nested())) return false;
37316                         { type = 1; return true;}
37317                         return false;
37318
37319                 }
37320                 template<typename V> bool encode(V& v) const
37321                 {
37322                         return v(ref_nested());
37323
37324                 }
37325                 protected:
37326                 template<typename V>  bool decode(size_t index, V& v)
37327                 {
37328                         clear();
37329                         switch(index)
37330                         {
37331                         case 1: type = 1; return v(ref_nested());
37332                         ref_nested().clear();
37333                         }
37334                         return false;
37335
37336                 }
37337                 template<typename V> bool encode(size_t index, V& v) const
37338                 {
37339                         if(index != type) {return false;} return v(ref_nested());
37340
37341                 }
37342                 private:
37343                 size_t type {0};
37344
37345         };
37346
37347 };
37348 /*
37349 ServedNRCellsToModify-Item::= SEQUENCE {
37350         old-nrcgi                                               NRCGI,
37351         servedNRCellInformation                 ServedNRCell-Information,
37352         nrNeighbourInformation                  NRNeighbour-Information                 OPTIONAL,
37353         nrDeactivationIndication                        DeactivationIndication                  OPTIONAL,
37354         iE-Extensions                                   ProtocolExtensionContainer { {ServedNRCellsToModify-Item-ExtIEs} } OPTIONAL,
37355         ...
37356 }
37357 */
37358
37359 struct ServedNRCellsToModify_Item : asn::sequence<5, 0, true, 3>
37360 {
37361         static constexpr const char* name() {return "ServedNRCellsToModify-Item";}
37362         using parent_t = asn::sequence<5, 0, true, 3>;
37363         struct old_nrcgi_t : NRCGI
37364         {
37365                 static constexpr const char* name() {return "old_nrcgi_t";}
37366                 using parent_t = NRCGI;
37367
37368         };
37369         old_nrcgi_t& ref_old_nrcgi() {return old_nrcgi;}
37370         old_nrcgi_t const& ref_old_nrcgi() const {return old_nrcgi;}
37371         struct servedNRCellInformation_t : ServedNRCell_Information
37372         {
37373                 static constexpr const char* name() {return "servedNRCellInformation_t";}
37374                 using parent_t = ServedNRCell_Information;
37375
37376         };
37377         servedNRCellInformation_t& ref_servedNRCellInformation() {return servedNRCellInformation;}
37378         servedNRCellInformation_t const& ref_servedNRCellInformation() const {return servedNRCellInformation;}
37379         struct nrNeighbourInformation_t : NRNeighbour_Information
37380         {
37381                 static constexpr const char* name() {return "nrNeighbourInformation_t";}
37382                 using parent_t = NRNeighbour_Information;
37383                 static constexpr bool optional = true;
37384
37385         };
37386         nrNeighbourInformation_t& set_nrNeighbourInformation() { nrNeighbourInformation.setpresent(true); return nrNeighbourInformation;}
37387         nrNeighbourInformation_t const* get_nrNeighbourInformation() const {return nrNeighbourInformation.is_valid() ? &nrNeighbourInformation : nullptr;}
37388         struct nrDeactivationIndication_t : DeactivationIndication
37389         {
37390                 static constexpr const char* name() {return "nrDeactivationIndication_t";}
37391                 using parent_t = DeactivationIndication;
37392                 static constexpr bool optional = true;
37393
37394         };
37395         nrDeactivationIndication_t& set_nrDeactivationIndication() { nrDeactivationIndication.setpresent(true); return nrDeactivationIndication;}
37396         nrDeactivationIndication_t const* get_nrDeactivationIndication() const {return nrDeactivationIndication.is_valid() ? &nrDeactivationIndication : nullptr;}
37397         struct iE_Extensions_t : ProtocolExtensionContainer<ServedNRCellsToModify_Item_ExtIEs>
37398         {
37399                 static constexpr const char* name() {return "iE_Extensions_t";}
37400                 using parent_t = ProtocolExtensionContainer<ServedNRCellsToModify_Item_ExtIEs>;
37401                 static constexpr bool optional = true;
37402
37403         };
37404         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
37405         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
37406         template<typename V> void decode(V& v)
37407         {
37408                 v(old_nrcgi);
37409                 v(servedNRCellInformation);
37410                 v(nrNeighbourInformation);
37411                 v(nrDeactivationIndication);
37412                 v(iE_Extensions);
37413
37414         };
37415         template<typename V> void encode(V& v) const
37416         {
37417                 v(old_nrcgi);
37418                 v(servedNRCellInformation);
37419                 v(nrNeighbourInformation);
37420                 v(nrDeactivationIndication);
37421                 v(iE_Extensions);
37422
37423         };
37424         void clear()
37425         {
37426                 old_nrcgi.clear();
37427                 servedNRCellInformation.clear();
37428                 nrNeighbourInformation.clear();
37429                 nrDeactivationIndication.clear();
37430                 iE_Extensions.clear();
37431
37432         };
37433         private:
37434         old_nrcgi_t     old_nrcgi;
37435         servedNRCellInformation_t       servedNRCellInformation;
37436         nrNeighbourInformation_t        nrNeighbourInformation;
37437         nrDeactivationIndication_t      nrDeactivationIndication;
37438         iE_Extensions_t iE_Extensions;
37439
37440 };
37441 /*
37442 ServedNRcellsToModifyENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF ServedNRCellsToModify-Item
37443 */
37444
37445 struct ServedNRcellsToModifyENDCConfUpdList_elm : ServedNRCellsToModify_Item
37446 {
37447         static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList_elm";}
37448         using parent_t = ServedNRCellsToModify_Item;
37449
37450 };
37451 struct ServedNRcellsToModifyENDCConfUpdList : asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>
37452 {
37453         static constexpr const char* name() {return "ServedNRcellsToModifyENDCConfUpdList";}
37454         using parent_t = asn::sequenceof<ServedNRcellsToModifyENDCConfUpdList_elm>;
37455         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
37456
37457 };
37458 /*
37459 ServedNRcellsToDeleteENDCConfUpdList ::= SEQUENCE (SIZE (1..maxCellinengNB)) OF NRCGI
37460 */
37461
37462 struct ServedNRcellsToDeleteENDCConfUpdList_elm : NRCGI
37463 {
37464         static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList_elm";}
37465         using parent_t = NRCGI;
37466
37467 };
37468 struct ServedNRcellsToDeleteENDCConfUpdList : asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>
37469 {
37470         static constexpr const char* name() {return "ServedNRcellsToDeleteENDCConfUpdList";}
37471         using parent_t = asn::sequenceof<ServedNRcellsToDeleteENDCConfUpdList_elm>;
37472         using constraint_t = asn::constraints<false,asn::span<1,  maxCellinengNB >>;
37473
37474 };
37475 /*
37476 En-gNB-ENDCConfigUpdateIEs X2AP-PROTOCOL-IES ::= {
37477         { ID id-ServedNRcellsENDCX2ManagementList               CRITICALITY reject      TYPE ServedNRcellsENDCX2ManagementList                  PRESENCE optional }|
37478         { ID id-ServedNRcellsToModifyListENDCConfUpd            CRITICALITY reject      TYPE ServedNRcellsToModifyENDCConfUpdList               PRESENCE optional }|
37479         { ID id-ServedNRcellsToDeleteListENDCConfUpd            CRITICALITY reject      TYPE ServedNRcellsToDeleteENDCConfUpdList               PRESENCE optional },
37480         ...
37481 }
37482 */
37483
37484 struct En_gNB_ENDCConfigUpdateIEs
37485 {
37486         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
37487         {
37488                 size_t get_index() const {return type;}
37489                 bool is_unknown() const { return type == 4; }
37490                 void clear() {type = 0;}
37491                 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=1;}
37492                 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(id_ServedNRcellsToModifyListENDCConfUpd); type=2;}
37493                 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(id_ServedNRcellsToDeleteListENDCConfUpd); type=3;}
37494                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
37495                 template<typename V>  bool decode(V& v)
37496                 {
37497                         clear();
37498                         if(!v(ref_nested())) return false;
37499                         if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 1; return true; }
37500                         else if(equal(id_ServedNRcellsToModifyListENDCConfUpd)) { type = 2; return true; }
37501                         else if(equal(id_ServedNRcellsToDeleteListENDCConfUpd)) { type = 3; return true; }
37502                         else { type = 4; return true;}
37503                         return false;
37504
37505                 }
37506                 template<typename V> bool encode(V& v) const
37507                 {
37508                         return v(ref_nested());
37509
37510                 }
37511                 protected:
37512                 template<typename V>  bool decode(size_t index, V& v)
37513                 {
37514                         clear();
37515                         switch(index)
37516                         {
37517                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
37518                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsToModifyListENDCConfUpd);} return false;
37519                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ServedNRcellsToDeleteListENDCConfUpd);} return false;
37520                         case 4: type = 4; return v(ref_nested());
37521                         ref_nested().clear();
37522                         }
37523                         return false;
37524
37525                 }
37526                 template<typename V> bool encode(size_t index, V& v) const
37527                 {
37528                         if(index != type) {return false;} return v(ref_nested());
37529
37530                 }
37531                 private:
37532                 size_t type {0};
37533
37534         };
37535         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
37536         {
37537                 size_t get_index() const {return type;}
37538                 bool is_unknown() const { return type == 4; }
37539                 void clear() {type = 0;}
37540                 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=1;}
37541                 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(reject); type=2;}
37542                 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(reject); type=3;}
37543                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
37544                 template<typename V>  bool decode(V& v)
37545                 {
37546                         clear();
37547                         if(!v(ref_nested())) return false;
37548                         if(equal(reject)) { type = 1; return true; }
37549                         else if(equal(reject)) { type = 2; return true; }
37550                         else if(equal(reject)) { type = 3; return true; }
37551                         else { type = 4; return true;}
37552                         return false;
37553
37554                 }
37555                 template<typename V> bool encode(V& v) const
37556                 {
37557                         return v(ref_nested());
37558
37559                 }
37560                 protected:
37561                 template<typename V>  bool decode(size_t index, V& v)
37562                 {
37563                         clear();
37564                         switch(index)
37565                         {
37566                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
37567                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
37568                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
37569                         case 4: type = 4; return v(ref_nested());
37570                         ref_nested().clear();
37571                         }
37572                         return false;
37573
37574                 }
37575                 template<typename V> bool encode(size_t index, V& v) const
37576                 {
37577                         if(index != type) {return false;} return v(ref_nested());
37578
37579                 }
37580                 private:
37581                 size_t type {0};
37582
37583         };
37584         struct Value_t : asn::typefield<true>
37585         {
37586                 ~Value_t()      {clear();}
37587                 size_t get_index() const {return type;}
37588                 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
37589                 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
37590                 ServedNRcellsToModifyENDCConfUpdList& select_id_ServedNRcellsToModifyListENDCConfUpd() { return set<ServedNRcellsToModifyENDCConfUpdList>(2); }
37591                 ServedNRcellsToModifyENDCConfUpdList const* get_id_ServedNRcellsToModifyListENDCConfUpd() const { return get<ServedNRcellsToModifyENDCConfUpdList>(2); }
37592                 ServedNRcellsToDeleteENDCConfUpdList& select_id_ServedNRcellsToDeleteListENDCConfUpd() { return set<ServedNRcellsToDeleteENDCConfUpdList>(3); }
37593                 ServedNRcellsToDeleteENDCConfUpdList const* get_id_ServedNRcellsToDeleteListENDCConfUpd() const { return get<ServedNRcellsToDeleteENDCConfUpdList>(3); }
37594                 bool is_unknown() const { return type == 4; }
37595                 void clear()
37596                 {
37597                         switch(type)
37598                         {
37599                         case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
37600                         case 2: var.destroy<ServedNRcellsToModifyENDCConfUpdList>(); break;
37601                         case 3: var.destroy<ServedNRcellsToDeleteENDCConfUpdList>(); break;
37602                         }
37603                         type = 0; ref_nested().clear();
37604                 }
37605                 template<typename V> static inline void enumerate(V& v)
37606                 {
37607                         v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
37608                         v.template operator()<ServedNRcellsToModifyENDCConfUpdList>(2);
37609                         v.template operator()<ServedNRcellsToDeleteENDCConfUpdList>(3);
37610
37611                 }
37612                 protected:
37613                 template<typename V> bool decode(size_t index, V& v)
37614                 {
37615                         clear();
37616                         switch(index)
37617                         {
37618                         case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
37619                         case 2: v(select_id_ServedNRcellsToModifyListENDCConfUpd()); return true;
37620                         case 3: v(select_id_ServedNRcellsToDeleteListENDCConfUpd()); return true;
37621                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
37622                         }
37623                         return false;
37624
37625                 }
37626                 template<typename V> bool encode(size_t index, V& v) const
37627                 {
37628                         if(index != type) return false;
37629                         switch(type)
37630                         {
37631                         case 1: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
37632                         case 2: v(var.as<ServedNRcellsToModifyENDCConfUpdList>()); return true;
37633                         case 3: v(var.as<ServedNRcellsToDeleteENDCConfUpdList>()); return true;
37634                         }
37635                         return false;
37636
37637                 }
37638                 private:
37639                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
37640                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
37641                 union union_type
37642                 {
37643                         char dummy1[sizeof(ServedNRcellsENDCX2ManagementList)];
37644                         char dummy2[sizeof(ServedNRcellsToDeleteENDCConfUpdList)];
37645                         char dummy3[sizeof(ServedNRcellsToModifyENDCConfUpdList)];
37646
37647                 };
37648                 asn::variant<sizeof(union_type)> var;
37649                 size_t type {0};
37650
37651         };
37652         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
37653         {
37654                 size_t get_index() const {return type;}
37655                 bool is_unknown() const { return type == 4; }
37656                 void clear() {type = 0;}
37657                 void select_id_ServedNRcellsENDCX2ManagementList() { set(optional); type=1;}
37658                 void select_id_ServedNRcellsToModifyListENDCConfUpd() { set(optional); type=2;}
37659                 void select_id_ServedNRcellsToDeleteListENDCConfUpd() { set(optional); type=3;}
37660                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
37661                 template<typename V>  bool decode(V& v)
37662                 {
37663                         clear();
37664                         if(!v(ref_nested())) return false;
37665                         if(equal(optional)) { type = 1; return true; }
37666                         else if(equal(optional)) { type = 2; return true; }
37667                         else if(equal(optional)) { type = 3; return true; }
37668                         else { type = 4; return true;}
37669                         return false;
37670
37671                 }
37672                 template<typename V> bool encode(V& v) const
37673                 {
37674                         return v(ref_nested());
37675
37676                 }
37677                 protected:
37678                 template<typename V>  bool decode(size_t index, V& v)
37679                 {
37680                         clear();
37681                         switch(index)
37682                         {
37683                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
37684                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
37685                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
37686                         case 4: type = 4; return v(ref_nested());
37687                         ref_nested().clear();
37688                         }
37689                         return false;
37690
37691                 }
37692                 template<typename V> bool encode(size_t index, V& v) const
37693                 {
37694                         if(index != type) {return false;} return v(ref_nested());
37695
37696                 }
37697                 private:
37698                 size_t type {0};
37699
37700         };
37701
37702 };
37703 /*
37704 InitiatingNodeType-EndcConfigUpdate::= CHOICE {
37705         init-eNB                        ProtocolIE-Container    {{ENB-ENDCConfigUpdateIEs}},
37706         init-en-gNB                     ProtocolIE-Container    {{En-gNB-ENDCConfigUpdateIEs}},
37707         ...
37708 }
37709 */
37710
37711 struct InitiatingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
37712 {
37713         static constexpr const char* name() {return "InitiatingNodeType-EndcConfigUpdate";}
37714         using parent_t = asn::choice<2, 0, true>;
37715         index_type get_index() const {return index;}
37716         bool is_unknown() const {return index == 3;}
37717         void set_unknown() { set_index(3);  }
37718         ~InitiatingNodeType_EndcConfigUpdate() {clear();}
37719         struct init_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>
37720         {
37721                 static constexpr const char* name() {return "init_eNB_t";}
37722                 using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateIEs>;
37723
37724         };
37725         struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>
37726         {
37727                 static constexpr const char* name() {return "init_en_gNB_t";}
37728                 using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateIEs>;
37729
37730         };
37731         void clear()
37732         {
37733                 switch(get_index())
37734                 {
37735                 case 1: var.destroy<init_eNB_t>(); break;
37736                 case 2: var.destroy<init_en_gNB_t>(); break;
37737                 }
37738                 index = 0;
37739                 base::clear();
37740         }
37741         template<typename V> bool decode(size_t idx, V& v)
37742         {
37743                 clear();
37744                 switch(idx)
37745                 {
37746                 case 1: set_index(1); return v(var.build<init_eNB_t>());
37747                 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
37748                 }
37749                 return false;
37750
37751         }
37752         template<typename V> bool encode(V& v) const
37753         {
37754                 switch(get_index())
37755                 {
37756                 case 1: return v(var.as<init_eNB_t>());
37757                 case 2: return v(var.as<init_en_gNB_t>());
37758                 }
37759                 return false;
37760         }
37761         template<typename V> static inline void enumerate(V& v)
37762         {
37763                 v.template operator()<init_eNB_t>(1);
37764                 v.template operator()<init_en_gNB_t>(2);
37765
37766         }
37767         init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
37768         init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
37769         init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
37770         init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
37771         private:
37772         void set_index(index_type i) {index = i; base::set();}
37773         union union_type
37774         {
37775                 char dummy1[sizeof(init_eNB_t)];
37776                 char dummy2[sizeof(init_en_gNB_t)];
37777
37778         };
37779         asn::variant<sizeof(union_type)>        var;
37780         index_type      index {0};
37781 };
37782 /*
37783 ENDCConfigurationUpdate-IEs X2AP-PROTOCOL-IES ::= {
37784         { ID id-InitiatingNodeType-EndcConfigUpdate                     CRITICALITY reject      TYPE InitiatingNodeType-EndcConfigUpdate                        PRESENCE mandatory},
37785         ...
37786 }
37787 */
37788
37789 struct ENDCConfigurationUpdate_IEs
37790 {
37791         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
37792         {
37793                 size_t get_index() const {return type;}
37794                 bool is_unknown() const { return type == 2; }
37795                 void clear() {type = 0;}
37796                 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(id_InitiatingNodeType_EndcConfigUpdate); type=1;}
37797                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
37798                 template<typename V>  bool decode(V& v)
37799                 {
37800                         clear();
37801                         if(!v(ref_nested())) return false;
37802                         if(equal(id_InitiatingNodeType_EndcConfigUpdate)) { type = 1; return true; }
37803                         else { type = 2; return true;}
37804                         return false;
37805
37806                 }
37807                 template<typename V> bool encode(V& v) const
37808                 {
37809                         return v(ref_nested());
37810
37811                 }
37812                 protected:
37813                 template<typename V>  bool decode(size_t index, V& v)
37814                 {
37815                         clear();
37816                         switch(index)
37817                         {
37818                         case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcConfigUpdate);} return false;
37819                         case 2: type = 2; return v(ref_nested());
37820                         ref_nested().clear();
37821                         }
37822                         return false;
37823
37824                 }
37825                 template<typename V> bool encode(size_t index, V& v) const
37826                 {
37827                         if(index != type) {return false;} return v(ref_nested());
37828
37829                 }
37830                 private:
37831                 size_t type {0};
37832
37833         };
37834         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
37835         {
37836                 size_t get_index() const {return type;}
37837                 bool is_unknown() const { return type == 2; }
37838                 void clear() {type = 0;}
37839                 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(reject); type=1;}
37840                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
37841                 template<typename V>  bool decode(V& v)
37842                 {
37843                         clear();
37844                         if(!v(ref_nested())) return false;
37845                         if(equal(reject)) { type = 1; return true; }
37846                         else { type = 2; return true;}
37847                         return false;
37848
37849                 }
37850                 template<typename V> bool encode(V& v) const
37851                 {
37852                         return v(ref_nested());
37853
37854                 }
37855                 protected:
37856                 template<typename V>  bool decode(size_t index, V& v)
37857                 {
37858                         clear();
37859                         switch(index)
37860                         {
37861                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
37862                         case 2: type = 2; return v(ref_nested());
37863                         ref_nested().clear();
37864                         }
37865                         return false;
37866
37867                 }
37868                 template<typename V> bool encode(size_t index, V& v) const
37869                 {
37870                         if(index != type) {return false;} return v(ref_nested());
37871
37872                 }
37873                 private:
37874                 size_t type {0};
37875
37876         };
37877         struct Value_t : asn::typefield<true>
37878         {
37879                 ~Value_t()      {clear();}
37880                 size_t get_index() const {return type;}
37881                 InitiatingNodeType_EndcConfigUpdate& select_id_InitiatingNodeType_EndcConfigUpdate() { return set<InitiatingNodeType_EndcConfigUpdate>(1); }
37882                 InitiatingNodeType_EndcConfigUpdate const* get_id_InitiatingNodeType_EndcConfigUpdate() const { return get<InitiatingNodeType_EndcConfigUpdate>(1); }
37883                 bool is_unknown() const { return type == 2; }
37884                 void clear()
37885                 {
37886                         switch(type)
37887                         {
37888                         case 1: var.destroy<InitiatingNodeType_EndcConfigUpdate>(); break;
37889                         }
37890                         type = 0; ref_nested().clear();
37891                 }
37892                 template<typename V> static inline void enumerate(V& v)
37893                 {
37894                         v.template operator()<InitiatingNodeType_EndcConfigUpdate>(1);
37895
37896                 }
37897                 protected:
37898                 template<typename V> bool decode(size_t index, V& v)
37899                 {
37900                         clear();
37901                         switch(index)
37902                         {
37903                         case 1: v(select_id_InitiatingNodeType_EndcConfigUpdate()); return true;
37904                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
37905                         }
37906                         return false;
37907
37908                 }
37909                 template<typename V> bool encode(size_t index, V& v) const
37910                 {
37911                         if(index != type) return false;
37912                         switch(type)
37913                         {
37914                         case 1: v(var.as<InitiatingNodeType_EndcConfigUpdate>()); return true;
37915                         }
37916                         return false;
37917
37918                 }
37919                 private:
37920                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
37921                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
37922                 union union_type
37923                 {
37924                         char dummy1[sizeof(InitiatingNodeType_EndcConfigUpdate)];
37925
37926                 };
37927                 asn::variant<sizeof(union_type)> var;
37928                 size_t type {0};
37929
37930         };
37931         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
37932         {
37933                 size_t get_index() const {return type;}
37934                 bool is_unknown() const { return type == 2; }
37935                 void clear() {type = 0;}
37936                 void select_id_InitiatingNodeType_EndcConfigUpdate() { set(mandatory); type=1;}
37937                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
37938                 template<typename V>  bool decode(V& v)
37939                 {
37940                         clear();
37941                         if(!v(ref_nested())) return false;
37942                         if(equal(mandatory)) { type = 1; return true; }
37943                         else { type = 2; return true;}
37944                         return false;
37945
37946                 }
37947                 template<typename V> bool encode(V& v) const
37948                 {
37949                         return v(ref_nested());
37950
37951                 }
37952                 protected:
37953                 template<typename V>  bool decode(size_t index, V& v)
37954                 {
37955                         clear();
37956                         switch(index)
37957                         {
37958                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
37959                         case 2: type = 2; return v(ref_nested());
37960                         ref_nested().clear();
37961                         }
37962                         return false;
37963
37964                 }
37965                 template<typename V> bool encode(size_t index, V& v) const
37966                 {
37967                         if(index != type) {return false;} return v(ref_nested());
37968
37969                 }
37970                 private:
37971                 size_t type {0};
37972
37973         };
37974
37975 };
37976 /*
37977 ENDCConfigurationUpdate ::= SEQUENCE {
37978         protocolIEs             ProtocolIE-Container    {{ENDCConfigurationUpdate-IEs}},
37979         ...
37980 }
37981 */
37982
37983 struct ENDCConfigurationUpdate : asn::sequence<1, 0, true, 0>
37984 {
37985         static constexpr const char* name() {return "ENDCConfigurationUpdate";}
37986         using parent_t = asn::sequence<1, 0, true, 0>;
37987         struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdate_IEs>
37988         {
37989                 static constexpr const char* name() {return "protocolIEs_t";}
37990                 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdate_IEs>;
37991
37992         };
37993         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
37994         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
37995         template<typename V> void decode(V& v)
37996         {
37997                 v(protocolIEs);
37998
37999         };
38000         template<typename V> void encode(V& v) const
38001         {
38002                 v(protocolIEs);
38003
38004         };
38005         void clear()
38006         {
38007                 protocolIEs.clear();
38008
38009         };
38010         private:
38011         protocolIEs_t   protocolIEs;
38012
38013 };
38014 /*
38015 En-gNB-ENDCConfigUpdateAckIEs X2AP-PROTOCOL-IES ::= {
38016         { ID id-ServedNRcellsENDCX2ManagementList               CRITICALITY reject      TYPE ServedNRcellsENDCX2ManagementList          PRESENCE optional},
38017         ...
38018 }
38019 */
38020
38021 struct En_gNB_ENDCConfigUpdateAckIEs
38022 {
38023         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38024         {
38025                 size_t get_index() const {return type;}
38026                 bool is_unknown() const { return type == 2; }
38027                 void clear() {type = 0;}
38028                 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=1;}
38029                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38030                 template<typename V>  bool decode(V& v)
38031                 {
38032                         clear();
38033                         if(!v(ref_nested())) return false;
38034                         if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 1; return true; }
38035                         else { type = 2; return true;}
38036                         return false;
38037
38038                 }
38039                 template<typename V> bool encode(V& v) const
38040                 {
38041                         return v(ref_nested());
38042
38043                 }
38044                 protected:
38045                 template<typename V>  bool decode(size_t index, V& v)
38046                 {
38047                         clear();
38048                         switch(index)
38049                         {
38050                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
38051                         case 2: type = 2; return v(ref_nested());
38052                         ref_nested().clear();
38053                         }
38054                         return false;
38055
38056                 }
38057                 template<typename V> bool encode(size_t index, V& v) const
38058                 {
38059                         if(index != type) {return false;} return v(ref_nested());
38060
38061                 }
38062                 private:
38063                 size_t type {0};
38064
38065         };
38066         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38067         {
38068                 size_t get_index() const {return type;}
38069                 bool is_unknown() const { return type == 2; }
38070                 void clear() {type = 0;}
38071                 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=1;}
38072                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38073                 template<typename V>  bool decode(V& v)
38074                 {
38075                         clear();
38076                         if(!v(ref_nested())) return false;
38077                         if(equal(reject)) { type = 1; return true; }
38078                         else { type = 2; return true;}
38079                         return false;
38080
38081                 }
38082                 template<typename V> bool encode(V& v) const
38083                 {
38084                         return v(ref_nested());
38085
38086                 }
38087                 protected:
38088                 template<typename V>  bool decode(size_t index, V& v)
38089                 {
38090                         clear();
38091                         switch(index)
38092                         {
38093                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38094                         case 2: type = 2; return v(ref_nested());
38095                         ref_nested().clear();
38096                         }
38097                         return false;
38098
38099                 }
38100                 template<typename V> bool encode(size_t index, V& v) const
38101                 {
38102                         if(index != type) {return false;} return v(ref_nested());
38103
38104                 }
38105                 private:
38106                 size_t type {0};
38107
38108         };
38109         struct Value_t : asn::typefield<true>
38110         {
38111                 ~Value_t()      {clear();}
38112                 size_t get_index() const {return type;}
38113                 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(1); }
38114                 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(1); }
38115                 bool is_unknown() const { return type == 2; }
38116                 void clear()
38117                 {
38118                         switch(type)
38119                         {
38120                         case 1: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
38121                         }
38122                         type = 0; ref_nested().clear();
38123                 }
38124                 template<typename V> static inline void enumerate(V& v)
38125                 {
38126                         v.template operator()<ServedNRcellsENDCX2ManagementList>(1);
38127
38128                 }
38129                 protected:
38130                 template<typename V> bool decode(size_t index, V& v)
38131                 {
38132                         clear();
38133                         switch(index)
38134                         {
38135                         case 1: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
38136                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38137                         }
38138                         return false;
38139
38140                 }
38141                 template<typename V> bool encode(size_t index, V& v) const
38142                 {
38143                         if(index != type) return false;
38144                         switch(type)
38145                         {
38146                         case 1: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
38147                         }
38148                         return false;
38149
38150                 }
38151                 private:
38152                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38153                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38154                 union union_type
38155                 {
38156                         char dummy1[sizeof(ServedNRcellsENDCX2ManagementList)];
38157
38158                 };
38159                 asn::variant<sizeof(union_type)> var;
38160                 size_t type {0};
38161
38162         };
38163         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38164         {
38165                 size_t get_index() const {return type;}
38166                 bool is_unknown() const { return type == 2; }
38167                 void clear() {type = 0;}
38168                 void select_id_ServedNRcellsENDCX2ManagementList() { set(optional); type=1;}
38169                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38170                 template<typename V>  bool decode(V& v)
38171                 {
38172                         clear();
38173                         if(!v(ref_nested())) return false;
38174                         if(equal(optional)) { type = 1; return true; }
38175                         else { type = 2; return true;}
38176                         return false;
38177
38178                 }
38179                 template<typename V> bool encode(V& v) const
38180                 {
38181                         return v(ref_nested());
38182
38183                 }
38184                 protected:
38185                 template<typename V>  bool decode(size_t index, V& v)
38186                 {
38187                         clear();
38188                         switch(index)
38189                         {
38190                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
38191                         case 2: type = 2; return v(ref_nested());
38192                         ref_nested().clear();
38193                         }
38194                         return false;
38195
38196                 }
38197                 template<typename V> bool encode(size_t index, V& v) const
38198                 {
38199                         if(index != type) {return false;} return v(ref_nested());
38200
38201                 }
38202                 private:
38203                 size_t type {0};
38204
38205         };
38206
38207 };
38208 /*
38209 RespondingNodeType-EndcConfigUpdate::= CHOICE {
38210         respond-eNB                     ProtocolIE-Container    {{ENB-ENDCConfigUpdateAckIEs}},
38211         respond-en-gNB          ProtocolIE-Container    {{En-gNB-ENDCConfigUpdateAckIEs}},
38212         ...
38213 }
38214 */
38215
38216 struct RespondingNodeType_EndcConfigUpdate : asn::choice<2, 0, true>
38217 {
38218         static constexpr const char* name() {return "RespondingNodeType-EndcConfigUpdate";}
38219         using parent_t = asn::choice<2, 0, true>;
38220         index_type get_index() const {return index;}
38221         bool is_unknown() const {return index == 3;}
38222         void set_unknown() { set_index(3);  }
38223         ~RespondingNodeType_EndcConfigUpdate() {clear();}
38224         struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>
38225         {
38226                 static constexpr const char* name() {return "respond_eNB_t";}
38227                 using parent_t = ProtocolIE_Container<ENB_ENDCConfigUpdateAckIEs>;
38228
38229         };
38230         struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>
38231         {
38232                 static constexpr const char* name() {return "respond_en_gNB_t";}
38233                 using parent_t = ProtocolIE_Container<En_gNB_ENDCConfigUpdateAckIEs>;
38234
38235         };
38236         void clear()
38237         {
38238                 switch(get_index())
38239                 {
38240                 case 1: var.destroy<respond_eNB_t>(); break;
38241                 case 2: var.destroy<respond_en_gNB_t>(); break;
38242                 }
38243                 index = 0;
38244                 base::clear();
38245         }
38246         template<typename V> bool decode(size_t idx, V& v)
38247         {
38248                 clear();
38249                 switch(idx)
38250                 {
38251                 case 1: set_index(1); return v(var.build<respond_eNB_t>());
38252                 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
38253                 }
38254                 return false;
38255
38256         }
38257         template<typename V> bool encode(V& v) const
38258         {
38259                 switch(get_index())
38260                 {
38261                 case 1: return v(var.as<respond_eNB_t>());
38262                 case 2: return v(var.as<respond_en_gNB_t>());
38263                 }
38264                 return false;
38265         }
38266         template<typename V> static inline void enumerate(V& v)
38267         {
38268                 v.template operator()<respond_eNB_t>(1);
38269                 v.template operator()<respond_en_gNB_t>(2);
38270
38271         }
38272         respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
38273         respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
38274         respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
38275         respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
38276         private:
38277         void set_index(index_type i) {index = i; base::set();}
38278         union union_type
38279         {
38280                 char dummy1[sizeof(respond_eNB_t)];
38281                 char dummy2[sizeof(respond_en_gNB_t)];
38282
38283         };
38284         asn::variant<sizeof(union_type)>        var;
38285         index_type      index {0};
38286 };
38287 /*
38288 ENDCConfigurationUpdateAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
38289         { ID id-RespondingNodeType-EndcConfigUpdate                     CRITICALITY reject      TYPE RespondingNodeType-EndcConfigUpdate                        PRESENCE mandatory},
38290         ...
38291 }
38292 */
38293
38294 struct ENDCConfigurationUpdateAcknowledge_IEs
38295 {
38296         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38297         {
38298                 size_t get_index() const {return type;}
38299                 bool is_unknown() const { return type == 2; }
38300                 void clear() {type = 0;}
38301                 void select_id_RespondingNodeType_EndcConfigUpdate() { set(id_RespondingNodeType_EndcConfigUpdate); type=1;}
38302                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38303                 template<typename V>  bool decode(V& v)
38304                 {
38305                         clear();
38306                         if(!v(ref_nested())) return false;
38307                         if(equal(id_RespondingNodeType_EndcConfigUpdate)) { type = 1; return true; }
38308                         else { type = 2; return true;}
38309                         return false;
38310
38311                 }
38312                 template<typename V> bool encode(V& v) const
38313                 {
38314                         return v(ref_nested());
38315
38316                 }
38317                 protected:
38318                 template<typename V>  bool decode(size_t index, V& v)
38319                 {
38320                         clear();
38321                         switch(index)
38322                         {
38323                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcConfigUpdate);} return false;
38324                         case 2: type = 2; return v(ref_nested());
38325                         ref_nested().clear();
38326                         }
38327                         return false;
38328
38329                 }
38330                 template<typename V> bool encode(size_t index, V& v) const
38331                 {
38332                         if(index != type) {return false;} return v(ref_nested());
38333
38334                 }
38335                 private:
38336                 size_t type {0};
38337
38338         };
38339         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38340         {
38341                 size_t get_index() const {return type;}
38342                 bool is_unknown() const { return type == 2; }
38343                 void clear() {type = 0;}
38344                 void select_id_RespondingNodeType_EndcConfigUpdate() { set(reject); type=1;}
38345                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38346                 template<typename V>  bool decode(V& v)
38347                 {
38348                         clear();
38349                         if(!v(ref_nested())) return false;
38350                         if(equal(reject)) { type = 1; return true; }
38351                         else { type = 2; return true;}
38352                         return false;
38353
38354                 }
38355                 template<typename V> bool encode(V& v) const
38356                 {
38357                         return v(ref_nested());
38358
38359                 }
38360                 protected:
38361                 template<typename V>  bool decode(size_t index, V& v)
38362                 {
38363                         clear();
38364                         switch(index)
38365                         {
38366                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38367                         case 2: type = 2; return v(ref_nested());
38368                         ref_nested().clear();
38369                         }
38370                         return false;
38371
38372                 }
38373                 template<typename V> bool encode(size_t index, V& v) const
38374                 {
38375                         if(index != type) {return false;} return v(ref_nested());
38376
38377                 }
38378                 private:
38379                 size_t type {0};
38380
38381         };
38382         struct Value_t : asn::typefield<true>
38383         {
38384                 ~Value_t()      {clear();}
38385                 size_t get_index() const {return type;}
38386                 RespondingNodeType_EndcConfigUpdate& select_id_RespondingNodeType_EndcConfigUpdate() { return set<RespondingNodeType_EndcConfigUpdate>(1); }
38387                 RespondingNodeType_EndcConfigUpdate const* get_id_RespondingNodeType_EndcConfigUpdate() const { return get<RespondingNodeType_EndcConfigUpdate>(1); }
38388                 bool is_unknown() const { return type == 2; }
38389                 void clear()
38390                 {
38391                         switch(type)
38392                         {
38393                         case 1: var.destroy<RespondingNodeType_EndcConfigUpdate>(); break;
38394                         }
38395                         type = 0; ref_nested().clear();
38396                 }
38397                 template<typename V> static inline void enumerate(V& v)
38398                 {
38399                         v.template operator()<RespondingNodeType_EndcConfigUpdate>(1);
38400
38401                 }
38402                 protected:
38403                 template<typename V> bool decode(size_t index, V& v)
38404                 {
38405                         clear();
38406                         switch(index)
38407                         {
38408                         case 1: v(select_id_RespondingNodeType_EndcConfigUpdate()); return true;
38409                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38410                         }
38411                         return false;
38412
38413                 }
38414                 template<typename V> bool encode(size_t index, V& v) const
38415                 {
38416                         if(index != type) return false;
38417                         switch(type)
38418                         {
38419                         case 1: v(var.as<RespondingNodeType_EndcConfigUpdate>()); return true;
38420                         }
38421                         return false;
38422
38423                 }
38424                 private:
38425                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38426                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38427                 union union_type
38428                 {
38429                         char dummy1[sizeof(RespondingNodeType_EndcConfigUpdate)];
38430
38431                 };
38432                 asn::variant<sizeof(union_type)> var;
38433                 size_t type {0};
38434
38435         };
38436         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38437         {
38438                 size_t get_index() const {return type;}
38439                 bool is_unknown() const { return type == 2; }
38440                 void clear() {type = 0;}
38441                 void select_id_RespondingNodeType_EndcConfigUpdate() { set(mandatory); type=1;}
38442                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38443                 template<typename V>  bool decode(V& v)
38444                 {
38445                         clear();
38446                         if(!v(ref_nested())) return false;
38447                         if(equal(mandatory)) { type = 1; return true; }
38448                         else { type = 2; return true;}
38449                         return false;
38450
38451                 }
38452                 template<typename V> bool encode(V& v) const
38453                 {
38454                         return v(ref_nested());
38455
38456                 }
38457                 protected:
38458                 template<typename V>  bool decode(size_t index, V& v)
38459                 {
38460                         clear();
38461                         switch(index)
38462                         {
38463                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38464                         case 2: type = 2; return v(ref_nested());
38465                         ref_nested().clear();
38466                         }
38467                         return false;
38468
38469                 }
38470                 template<typename V> bool encode(size_t index, V& v) const
38471                 {
38472                         if(index != type) {return false;} return v(ref_nested());
38473
38474                 }
38475                 private:
38476                 size_t type {0};
38477
38478         };
38479
38480 };
38481 /*
38482 ENDCConfigurationUpdateAcknowledge ::= SEQUENCE {
38483         protocolIEs             ProtocolIE-Container    {{ENDCConfigurationUpdateAcknowledge-IEs}},
38484         ...
38485 }
38486 */
38487
38488 struct ENDCConfigurationUpdateAcknowledge : asn::sequence<1, 0, true, 0>
38489 {
38490         static constexpr const char* name() {return "ENDCConfigurationUpdateAcknowledge";}
38491         using parent_t = asn::sequence<1, 0, true, 0>;
38492         struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>
38493         {
38494                 static constexpr const char* name() {return "protocolIEs_t";}
38495                 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateAcknowledge_IEs>;
38496
38497         };
38498         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38499         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38500         template<typename V> void decode(V& v)
38501         {
38502                 v(protocolIEs);
38503
38504         };
38505         template<typename V> void encode(V& v) const
38506         {
38507                 v(protocolIEs);
38508
38509         };
38510         void clear()
38511         {
38512                 protocolIEs.clear();
38513
38514         };
38515         private:
38516         protocolIEs_t   protocolIEs;
38517
38518 };
38519 /*
38520 ENDCConfigurationUpdateFailure-IEs X2AP-PROTOCOL-IES ::= {
38521         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
38522         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional }|
38523         { ID id-TimeToWait                                      CRITICALITY ignore      TYPE TimeToWait                                 PRESENCE optional },
38524         ...
38525 }
38526 */
38527
38528 struct ENDCConfigurationUpdateFailure_IEs
38529 {
38530         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38531         {
38532                 size_t get_index() const {return type;}
38533                 bool is_unknown() const { return type == 4; }
38534                 void clear() {type = 0;}
38535                 void select_id_Cause() { set(id_Cause); type=1;}
38536                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
38537                 void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
38538                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38539                 template<typename V>  bool decode(V& v)
38540                 {
38541                         clear();
38542                         if(!v(ref_nested())) return false;
38543                         if(equal(id_Cause)) { type = 1; return true; }
38544                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
38545                         else if(equal(id_TimeToWait)) { type = 3; return true; }
38546                         else { type = 4; return true;}
38547                         return false;
38548
38549                 }
38550                 template<typename V> bool encode(V& v) const
38551                 {
38552                         return v(ref_nested());
38553
38554                 }
38555                 protected:
38556                 template<typename V>  bool decode(size_t index, V& v)
38557                 {
38558                         clear();
38559                         switch(index)
38560                         {
38561                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
38562                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
38563                         case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
38564                         case 4: type = 4; return v(ref_nested());
38565                         ref_nested().clear();
38566                         }
38567                         return false;
38568
38569                 }
38570                 template<typename V> bool encode(size_t index, V& v) const
38571                 {
38572                         if(index != type) {return false;} return v(ref_nested());
38573
38574                 }
38575                 private:
38576                 size_t type {0};
38577
38578         };
38579         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38580         {
38581                 size_t get_index() const {return type;}
38582                 bool is_unknown() const { return type == 4; }
38583                 void clear() {type = 0;}
38584                 void select_id_Cause() { set(ignore); type=1;}
38585                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
38586                 void select_id_TimeToWait() { set(ignore); type=3;}
38587                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38588                 template<typename V>  bool decode(V& v)
38589                 {
38590                         clear();
38591                         if(!v(ref_nested())) return false;
38592                         if(equal(ignore)) { type = 1; return true; }
38593                         else if(equal(ignore)) { type = 2; return true; }
38594                         else if(equal(ignore)) { type = 3; return true; }
38595                         else { type = 4; return true;}
38596                         return false;
38597
38598                 }
38599                 template<typename V> bool encode(V& v) const
38600                 {
38601                         return v(ref_nested());
38602
38603                 }
38604                 protected:
38605                 template<typename V>  bool decode(size_t index, V& v)
38606                 {
38607                         clear();
38608                         switch(index)
38609                         {
38610                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
38611                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
38612                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
38613                         case 4: type = 4; return v(ref_nested());
38614                         ref_nested().clear();
38615                         }
38616                         return false;
38617
38618                 }
38619                 template<typename V> bool encode(size_t index, V& v) const
38620                 {
38621                         if(index != type) {return false;} return v(ref_nested());
38622
38623                 }
38624                 private:
38625                 size_t type {0};
38626
38627         };
38628         struct Value_t : asn::typefield<true>
38629         {
38630                 ~Value_t()      {clear();}
38631                 size_t get_index() const {return type;}
38632                 Cause& select_id_Cause() { return set<Cause>(1); }
38633                 Cause const* get_id_Cause() const { return get<Cause>(1); }
38634                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
38635                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
38636                 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
38637                 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
38638                 bool is_unknown() const { return type == 4; }
38639                 void clear()
38640                 {
38641                         switch(type)
38642                         {
38643                         case 1: var.destroy<Cause>(); break;
38644                         case 2: var.destroy<CriticalityDiagnostics>(); break;
38645                         case 3: var.destroy<TimeToWait>(); break;
38646                         }
38647                         type = 0; ref_nested().clear();
38648                 }
38649                 template<typename V> static inline void enumerate(V& v)
38650                 {
38651                         v.template operator()<Cause>(1);
38652                         v.template operator()<CriticalityDiagnostics>(2);
38653                         v.template operator()<TimeToWait>(3);
38654
38655                 }
38656                 protected:
38657                 template<typename V> bool decode(size_t index, V& v)
38658                 {
38659                         clear();
38660                         switch(index)
38661                         {
38662                         case 1: v(select_id_Cause()); return true;
38663                         case 2: v(select_id_CriticalityDiagnostics()); return true;
38664                         case 3: v(select_id_TimeToWait()); return true;
38665                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
38666                         }
38667                         return false;
38668
38669                 }
38670                 template<typename V> bool encode(size_t index, V& v) const
38671                 {
38672                         if(index != type) return false;
38673                         switch(type)
38674                         {
38675                         case 1: v(var.as<Cause>()); return true;
38676                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
38677                         case 3: v(var.as<TimeToWait>()); return true;
38678                         }
38679                         return false;
38680
38681                 }
38682                 private:
38683                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38684                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38685                 union union_type
38686                 {
38687                         char dummy1[sizeof(Cause)];
38688                         char dummy2[sizeof(CriticalityDiagnostics)];
38689                         char dummy3[sizeof(TimeToWait)];
38690
38691                 };
38692                 asn::variant<sizeof(union_type)> var;
38693                 size_t type {0};
38694
38695         };
38696         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38697         {
38698                 size_t get_index() const {return type;}
38699                 bool is_unknown() const { return type == 4; }
38700                 void clear() {type = 0;}
38701                 void select_id_Cause() { set(mandatory); type=1;}
38702                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
38703                 void select_id_TimeToWait() { set(optional); type=3;}
38704                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38705                 template<typename V>  bool decode(V& v)
38706                 {
38707                         clear();
38708                         if(!v(ref_nested())) return false;
38709                         if(equal(mandatory)) { type = 1; return true; }
38710                         else if(equal(optional)) { type = 2; return true; }
38711                         else if(equal(optional)) { type = 3; return true; }
38712                         else { type = 4; return true;}
38713                         return false;
38714
38715                 }
38716                 template<typename V> bool encode(V& v) const
38717                 {
38718                         return v(ref_nested());
38719
38720                 }
38721                 protected:
38722                 template<typename V>  bool decode(size_t index, V& v)
38723                 {
38724                         clear();
38725                         switch(index)
38726                         {
38727                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38728                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
38729                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
38730                         case 4: type = 4; return v(ref_nested());
38731                         ref_nested().clear();
38732                         }
38733                         return false;
38734
38735                 }
38736                 template<typename V> bool encode(size_t index, V& v) const
38737                 {
38738                         if(index != type) {return false;} return v(ref_nested());
38739
38740                 }
38741                 private:
38742                 size_t type {0};
38743
38744         };
38745
38746 };
38747 /*
38748 ENDCConfigurationUpdateFailure ::= SEQUENCE {
38749         protocolIEs             ProtocolIE-Container    {{ENDCConfigurationUpdateFailure-IEs}},
38750         ...
38751 }
38752 */
38753
38754 struct ENDCConfigurationUpdateFailure : asn::sequence<1, 0, true, 0>
38755 {
38756         static constexpr const char* name() {return "ENDCConfigurationUpdateFailure";}
38757         using parent_t = asn::sequence<1, 0, true, 0>;
38758         struct protocolIEs_t : ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>
38759         {
38760                 static constexpr const char* name() {return "protocolIEs_t";}
38761                 using parent_t = ProtocolIE_Container<ENDCConfigurationUpdateFailure_IEs>;
38762
38763         };
38764         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38765         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38766         template<typename V> void decode(V& v)
38767         {
38768                 v(protocolIEs);
38769
38770         };
38771         template<typename V> void encode(V& v) const
38772         {
38773                 v(protocolIEs);
38774
38775         };
38776         void clear()
38777         {
38778                 protocolIEs.clear();
38779
38780         };
38781         private:
38782         protocolIEs_t   protocolIEs;
38783
38784 };
38785 /*
38786 ENDCPartialResetConfirm-IEs X2AP-PROTOCOL-IES ::= {
38787         { ID id-UEs-Admitted-ToBeReset                          CRITICALITY reject      TYPE UEsToBeResetList                           PRESENCE mandatory},
38788         ...
38789 }
38790 */
38791
38792 struct ENDCPartialResetConfirm_IEs
38793 {
38794         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
38795         {
38796                 size_t get_index() const {return type;}
38797                 bool is_unknown() const { return type == 2; }
38798                 void clear() {type = 0;}
38799                 void select_id_UEs_Admitted_ToBeReset() { set(id_UEs_Admitted_ToBeReset); type=1;}
38800                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
38801                 template<typename V>  bool decode(V& v)
38802                 {
38803                         clear();
38804                         if(!v(ref_nested())) return false;
38805                         if(equal(id_UEs_Admitted_ToBeReset)) { type = 1; return true; }
38806                         else { type = 2; return true;}
38807                         return false;
38808
38809                 }
38810                 template<typename V> bool encode(V& v) const
38811                 {
38812                         return v(ref_nested());
38813
38814                 }
38815                 protected:
38816                 template<typename V>  bool decode(size_t index, V& v)
38817                 {
38818                         clear();
38819                         switch(index)
38820                         {
38821                         case 1: type = 1; if(v(ref_nested())) { return equal(id_UEs_Admitted_ToBeReset);} return false;
38822                         case 2: type = 2; return v(ref_nested());
38823                         ref_nested().clear();
38824                         }
38825                         return false;
38826
38827                 }
38828                 template<typename V> bool encode(size_t index, V& v) const
38829                 {
38830                         if(index != type) {return false;} return v(ref_nested());
38831
38832                 }
38833                 private:
38834                 size_t type {0};
38835
38836         };
38837         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
38838         {
38839                 size_t get_index() const {return type;}
38840                 bool is_unknown() const { return type == 2; }
38841                 void clear() {type = 0;}
38842                 void select_id_UEs_Admitted_ToBeReset() { set(reject); type=1;}
38843                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
38844                 template<typename V>  bool decode(V& v)
38845                 {
38846                         clear();
38847                         if(!v(ref_nested())) return false;
38848                         if(equal(reject)) { type = 1; return true; }
38849                         else { type = 2; return true;}
38850                         return false;
38851
38852                 }
38853                 template<typename V> bool encode(V& v) const
38854                 {
38855                         return v(ref_nested());
38856
38857                 }
38858                 protected:
38859                 template<typename V>  bool decode(size_t index, V& v)
38860                 {
38861                         clear();
38862                         switch(index)
38863                         {
38864                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
38865                         case 2: type = 2; return v(ref_nested());
38866                         ref_nested().clear();
38867                         }
38868                         return false;
38869
38870                 }
38871                 template<typename V> bool encode(size_t index, V& v) const
38872                 {
38873                         if(index != type) {return false;} return v(ref_nested());
38874
38875                 }
38876                 private:
38877                 size_t type {0};
38878
38879         };
38880         struct Value_t : asn::typefield<true>
38881         {
38882                 ~Value_t()      {clear();}
38883                 size_t get_index() const {return type;}
38884                 UEsToBeResetList& select_id_UEs_Admitted_ToBeReset() { return set<UEsToBeResetList>(1); }
38885                 UEsToBeResetList const* get_id_UEs_Admitted_ToBeReset() const { return get<UEsToBeResetList>(1); }
38886                 bool is_unknown() const { return type == 2; }
38887                 void clear()
38888                 {
38889                         switch(type)
38890                         {
38891                         case 1: var.destroy<UEsToBeResetList>(); break;
38892                         }
38893                         type = 0; ref_nested().clear();
38894                 }
38895                 template<typename V> static inline void enumerate(V& v)
38896                 {
38897                         v.template operator()<UEsToBeResetList>(1);
38898
38899                 }
38900                 protected:
38901                 template<typename V> bool decode(size_t index, V& v)
38902                 {
38903                         clear();
38904                         switch(index)
38905                         {
38906                         case 1: v(select_id_UEs_Admitted_ToBeReset()); return true;
38907                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
38908                         }
38909                         return false;
38910
38911                 }
38912                 template<typename V> bool encode(size_t index, V& v) const
38913                 {
38914                         if(index != type) return false;
38915                         switch(type)
38916                         {
38917                         case 1: v(var.as<UEsToBeResetList>()); return true;
38918                         }
38919                         return false;
38920
38921                 }
38922                 private:
38923                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
38924                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
38925                 union union_type
38926                 {
38927                         char dummy1[sizeof(UEsToBeResetList)];
38928
38929                 };
38930                 asn::variant<sizeof(union_type)> var;
38931                 size_t type {0};
38932
38933         };
38934         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
38935         {
38936                 size_t get_index() const {return type;}
38937                 bool is_unknown() const { return type == 2; }
38938                 void clear() {type = 0;}
38939                 void select_id_UEs_Admitted_ToBeReset() { set(mandatory); type=1;}
38940                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
38941                 template<typename V>  bool decode(V& v)
38942                 {
38943                         clear();
38944                         if(!v(ref_nested())) return false;
38945                         if(equal(mandatory)) { type = 1; return true; }
38946                         else { type = 2; return true;}
38947                         return false;
38948
38949                 }
38950                 template<typename V> bool encode(V& v) const
38951                 {
38952                         return v(ref_nested());
38953
38954                 }
38955                 protected:
38956                 template<typename V>  bool decode(size_t index, V& v)
38957                 {
38958                         clear();
38959                         switch(index)
38960                         {
38961                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
38962                         case 2: type = 2; return v(ref_nested());
38963                         ref_nested().clear();
38964                         }
38965                         return false;
38966
38967                 }
38968                 template<typename V> bool encode(size_t index, V& v) const
38969                 {
38970                         if(index != type) {return false;} return v(ref_nested());
38971
38972                 }
38973                 private:
38974                 size_t type {0};
38975
38976         };
38977
38978 };
38979 /*
38980 ENDCPartialResetConfirm ::= SEQUENCE {
38981         protocolIEs             ProtocolIE-Container    {{ENDCPartialResetConfirm-IEs}},
38982         ...
38983 }
38984 */
38985
38986 struct ENDCPartialResetConfirm : asn::sequence<1, 0, true, 0>
38987 {
38988         static constexpr const char* name() {return "ENDCPartialResetConfirm";}
38989         using parent_t = asn::sequence<1, 0, true, 0>;
38990         struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetConfirm_IEs>
38991         {
38992                 static constexpr const char* name() {return "protocolIEs_t";}
38993                 using parent_t = ProtocolIE_Container<ENDCPartialResetConfirm_IEs>;
38994
38995         };
38996         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
38997         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
38998         template<typename V> void decode(V& v)
38999         {
39000                 v(protocolIEs);
39001
39002         };
39003         template<typename V> void encode(V& v) const
39004         {
39005                 v(protocolIEs);
39006
39007         };
39008         void clear()
39009         {
39010                 protocolIEs.clear();
39011
39012         };
39013         private:
39014         protocolIEs_t   protocolIEs;
39015
39016 };
39017 /*
39018 ENDCPartialResetRequired-IEs X2AP-PROTOCOL-IES ::= {
39019         { ID id-UEs-ToBeReset                           CRITICALITY reject      TYPE UEsToBeResetList                                   PRESENCE mandatory}|
39020         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                                              PRESENCE mandatory },
39021         ...
39022 }
39023 */
39024
39025 struct ENDCPartialResetRequired_IEs
39026 {
39027         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39028         {
39029                 size_t get_index() const {return type;}
39030                 bool is_unknown() const { return type == 3; }
39031                 void clear() {type = 0;}
39032                 void select_id_UEs_ToBeReset() { set(id_UEs_ToBeReset); type=1;}
39033                 void select_id_Cause() { set(id_Cause); type=2;}
39034                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39035                 template<typename V>  bool decode(V& v)
39036                 {
39037                         clear();
39038                         if(!v(ref_nested())) return false;
39039                         if(equal(id_UEs_ToBeReset)) { type = 1; return true; }
39040                         else if(equal(id_Cause)) { type = 2; return true; }
39041                         else { type = 3; return true;}
39042                         return false;
39043
39044                 }
39045                 template<typename V> bool encode(V& v) const
39046                 {
39047                         return v(ref_nested());
39048
39049                 }
39050                 protected:
39051                 template<typename V>  bool decode(size_t index, V& v)
39052                 {
39053                         clear();
39054                         switch(index)
39055                         {
39056                         case 1: type = 1; if(v(ref_nested())) { return equal(id_UEs_ToBeReset);} return false;
39057                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
39058                         case 3: type = 3; return v(ref_nested());
39059                         ref_nested().clear();
39060                         }
39061                         return false;
39062
39063                 }
39064                 template<typename V> bool encode(size_t index, V& v) const
39065                 {
39066                         if(index != type) {return false;} return v(ref_nested());
39067
39068                 }
39069                 private:
39070                 size_t type {0};
39071
39072         };
39073         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39074         {
39075                 size_t get_index() const {return type;}
39076                 bool is_unknown() const { return type == 3; }
39077                 void clear() {type = 0;}
39078                 void select_id_UEs_ToBeReset() { set(reject); type=1;}
39079                 void select_id_Cause() { set(ignore); type=2;}
39080                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39081                 template<typename V>  bool decode(V& v)
39082                 {
39083                         clear();
39084                         if(!v(ref_nested())) return false;
39085                         if(equal(reject)) { type = 1; return true; }
39086                         else if(equal(ignore)) { type = 2; return true; }
39087                         else { type = 3; return true;}
39088                         return false;
39089
39090                 }
39091                 template<typename V> bool encode(V& v) const
39092                 {
39093                         return v(ref_nested());
39094
39095                 }
39096                 protected:
39097                 template<typename V>  bool decode(size_t index, V& v)
39098                 {
39099                         clear();
39100                         switch(index)
39101                         {
39102                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39103                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
39104                         case 3: type = 3; return v(ref_nested());
39105                         ref_nested().clear();
39106                         }
39107                         return false;
39108
39109                 }
39110                 template<typename V> bool encode(size_t index, V& v) const
39111                 {
39112                         if(index != type) {return false;} return v(ref_nested());
39113
39114                 }
39115                 private:
39116                 size_t type {0};
39117
39118         };
39119         struct Value_t : asn::typefield<true>
39120         {
39121                 ~Value_t()      {clear();}
39122                 size_t get_index() const {return type;}
39123                 UEsToBeResetList& select_id_UEs_ToBeReset() { return set<UEsToBeResetList>(1); }
39124                 UEsToBeResetList const* get_id_UEs_ToBeReset() const { return get<UEsToBeResetList>(1); }
39125                 Cause& select_id_Cause() { return set<Cause>(2); }
39126                 Cause const* get_id_Cause() const { return get<Cause>(2); }
39127                 bool is_unknown() const { return type == 3; }
39128                 void clear()
39129                 {
39130                         switch(type)
39131                         {
39132                         case 1: var.destroy<UEsToBeResetList>(); break;
39133                         case 2: var.destroy<Cause>(); break;
39134                         }
39135                         type = 0; ref_nested().clear();
39136                 }
39137                 template<typename V> static inline void enumerate(V& v)
39138                 {
39139                         v.template operator()<UEsToBeResetList>(1);
39140                         v.template operator()<Cause>(2);
39141
39142                 }
39143                 protected:
39144                 template<typename V> bool decode(size_t index, V& v)
39145                 {
39146                         clear();
39147                         switch(index)
39148                         {
39149                         case 1: v(select_id_UEs_ToBeReset()); return true;
39150                         case 2: v(select_id_Cause()); return true;
39151                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
39152                         }
39153                         return false;
39154
39155                 }
39156                 template<typename V> bool encode(size_t index, V& v) const
39157                 {
39158                         if(index != type) return false;
39159                         switch(type)
39160                         {
39161                         case 1: v(var.as<UEsToBeResetList>()); return true;
39162                         case 2: v(var.as<Cause>()); return true;
39163                         }
39164                         return false;
39165
39166                 }
39167                 private:
39168                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39169                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39170                 union union_type
39171                 {
39172                         char dummy1[sizeof(Cause)];
39173                         char dummy2[sizeof(UEsToBeResetList)];
39174
39175                 };
39176                 asn::variant<sizeof(union_type)> var;
39177                 size_t type {0};
39178
39179         };
39180         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39181         {
39182                 size_t get_index() const {return type;}
39183                 bool is_unknown() const { return type == 3; }
39184                 void clear() {type = 0;}
39185                 void select_id_UEs_ToBeReset() { set(mandatory); type=1;}
39186                 void select_id_Cause() { set(mandatory); type=2;}
39187                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39188                 template<typename V>  bool decode(V& v)
39189                 {
39190                         clear();
39191                         if(!v(ref_nested())) return false;
39192                         if(equal(mandatory)) { type = 1; return true; }
39193                         else if(equal(mandatory)) { type = 2; return true; }
39194                         else { type = 3; return true;}
39195                         return false;
39196
39197                 }
39198                 template<typename V> bool encode(V& v) const
39199                 {
39200                         return v(ref_nested());
39201
39202                 }
39203                 protected:
39204                 template<typename V>  bool decode(size_t index, V& v)
39205                 {
39206                         clear();
39207                         switch(index)
39208                         {
39209                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39210                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
39211                         case 3: type = 3; return v(ref_nested());
39212                         ref_nested().clear();
39213                         }
39214                         return false;
39215
39216                 }
39217                 template<typename V> bool encode(size_t index, V& v) const
39218                 {
39219                         if(index != type) {return false;} return v(ref_nested());
39220
39221                 }
39222                 private:
39223                 size_t type {0};
39224
39225         };
39226
39227 };
39228 /*
39229 ENDCPartialResetRequired ::= SEQUENCE {
39230         protocolIEs             ProtocolIE-Container    {{ENDCPartialResetRequired-IEs}},
39231         ...
39232 }
39233 */
39234
39235 struct ENDCPartialResetRequired : asn::sequence<1, 0, true, 0>
39236 {
39237         static constexpr const char* name() {return "ENDCPartialResetRequired";}
39238         using parent_t = asn::sequence<1, 0, true, 0>;
39239         struct protocolIEs_t : ProtocolIE_Container<ENDCPartialResetRequired_IEs>
39240         {
39241                 static constexpr const char* name() {return "protocolIEs_t";}
39242                 using parent_t = ProtocolIE_Container<ENDCPartialResetRequired_IEs>;
39243
39244         };
39245         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
39246         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
39247         template<typename V> void decode(V& v)
39248         {
39249                 v(protocolIEs);
39250
39251         };
39252         template<typename V> void encode(V& v) const
39253         {
39254                 v(protocolIEs);
39255
39256         };
39257         void clear()
39258         {
39259                 protocolIEs.clear();
39260
39261         };
39262         private:
39263         protocolIEs_t   protocolIEs;
39264
39265 };
39266 /*
39267 ENDCX2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
39268         { ID id-Cause                                   CRITICALITY ignore              TYPE Cause                                                              PRESENCE mandatory} |
39269         { ID id-CriticalityDiagnostics  CRITICALITY ignore              TYPE CriticalityDiagnostics                             PRESENCE optional },
39270         ...
39271 }
39272 */
39273
39274 struct ENDCX2RemovalFailure_IEs
39275 {
39276         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39277         {
39278                 size_t get_index() const {return type;}
39279                 bool is_unknown() const { return type == 3; }
39280                 void clear() {type = 0;}
39281                 void select_id_Cause() { set(id_Cause); type=1;}
39282                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
39283                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39284                 template<typename V>  bool decode(V& v)
39285                 {
39286                         clear();
39287                         if(!v(ref_nested())) return false;
39288                         if(equal(id_Cause)) { type = 1; return true; }
39289                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
39290                         else { type = 3; return true;}
39291                         return false;
39292
39293                 }
39294                 template<typename V> bool encode(V& v) const
39295                 {
39296                         return v(ref_nested());
39297
39298                 }
39299                 protected:
39300                 template<typename V>  bool decode(size_t index, V& v)
39301                 {
39302                         clear();
39303                         switch(index)
39304                         {
39305                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
39306                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
39307                         case 3: type = 3; return v(ref_nested());
39308                         ref_nested().clear();
39309                         }
39310                         return false;
39311
39312                 }
39313                 template<typename V> bool encode(size_t index, V& v) const
39314                 {
39315                         if(index != type) {return false;} return v(ref_nested());
39316
39317                 }
39318                 private:
39319                 size_t type {0};
39320
39321         };
39322         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39323         {
39324                 size_t get_index() const {return type;}
39325                 bool is_unknown() const { return type == 3; }
39326                 void clear() {type = 0;}
39327                 void select_id_Cause() { set(ignore); type=1;}
39328                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
39329                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39330                 template<typename V>  bool decode(V& v)
39331                 {
39332                         clear();
39333                         if(!v(ref_nested())) return false;
39334                         if(equal(ignore)) { type = 1; return true; }
39335                         else if(equal(ignore)) { type = 2; return true; }
39336                         else { type = 3; return true;}
39337                         return false;
39338
39339                 }
39340                 template<typename V> bool encode(V& v) const
39341                 {
39342                         return v(ref_nested());
39343
39344                 }
39345                 protected:
39346                 template<typename V>  bool decode(size_t index, V& v)
39347                 {
39348                         clear();
39349                         switch(index)
39350                         {
39351                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
39352                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
39353                         case 3: type = 3; return v(ref_nested());
39354                         ref_nested().clear();
39355                         }
39356                         return false;
39357
39358                 }
39359                 template<typename V> bool encode(size_t index, V& v) const
39360                 {
39361                         if(index != type) {return false;} return v(ref_nested());
39362
39363                 }
39364                 private:
39365                 size_t type {0};
39366
39367         };
39368         struct Value_t : asn::typefield<true>
39369         {
39370                 ~Value_t()      {clear();}
39371                 size_t get_index() const {return type;}
39372                 Cause& select_id_Cause() { return set<Cause>(1); }
39373                 Cause const* get_id_Cause() const { return get<Cause>(1); }
39374                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
39375                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
39376                 bool is_unknown() const { return type == 3; }
39377                 void clear()
39378                 {
39379                         switch(type)
39380                         {
39381                         case 1: var.destroy<Cause>(); break;
39382                         case 2: var.destroy<CriticalityDiagnostics>(); break;
39383                         }
39384                         type = 0; ref_nested().clear();
39385                 }
39386                 template<typename V> static inline void enumerate(V& v)
39387                 {
39388                         v.template operator()<Cause>(1);
39389                         v.template operator()<CriticalityDiagnostics>(2);
39390
39391                 }
39392                 protected:
39393                 template<typename V> bool decode(size_t index, V& v)
39394                 {
39395                         clear();
39396                         switch(index)
39397                         {
39398                         case 1: v(select_id_Cause()); return true;
39399                         case 2: v(select_id_CriticalityDiagnostics()); return true;
39400                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
39401                         }
39402                         return false;
39403
39404                 }
39405                 template<typename V> bool encode(size_t index, V& v) const
39406                 {
39407                         if(index != type) return false;
39408                         switch(type)
39409                         {
39410                         case 1: v(var.as<Cause>()); return true;
39411                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
39412                         }
39413                         return false;
39414
39415                 }
39416                 private:
39417                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39418                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39419                 union union_type
39420                 {
39421                         char dummy1[sizeof(Cause)];
39422                         char dummy2[sizeof(CriticalityDiagnostics)];
39423
39424                 };
39425                 asn::variant<sizeof(union_type)> var;
39426                 size_t type {0};
39427
39428         };
39429         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39430         {
39431                 size_t get_index() const {return type;}
39432                 bool is_unknown() const { return type == 3; }
39433                 void clear() {type = 0;}
39434                 void select_id_Cause() { set(mandatory); type=1;}
39435                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
39436                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39437                 template<typename V>  bool decode(V& v)
39438                 {
39439                         clear();
39440                         if(!v(ref_nested())) return false;
39441                         if(equal(mandatory)) { type = 1; return true; }
39442                         else if(equal(optional)) { type = 2; return true; }
39443                         else { type = 3; return true;}
39444                         return false;
39445
39446                 }
39447                 template<typename V> bool encode(V& v) const
39448                 {
39449                         return v(ref_nested());
39450
39451                 }
39452                 protected:
39453                 template<typename V>  bool decode(size_t index, V& v)
39454                 {
39455                         clear();
39456                         switch(index)
39457                         {
39458                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39459                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
39460                         case 3: type = 3; return v(ref_nested());
39461                         ref_nested().clear();
39462                         }
39463                         return false;
39464
39465                 }
39466                 template<typename V> bool encode(size_t index, V& v) const
39467                 {
39468                         if(index != type) {return false;} return v(ref_nested());
39469
39470                 }
39471                 private:
39472                 size_t type {0};
39473
39474         };
39475
39476 };
39477 /*
39478 ENDCX2RemovalFailure ::= SEQUENCE {
39479         protocolIEs             ProtocolIE-Container    {{ENDCX2RemovalFailure-IEs}},
39480         ...
39481 }
39482 */
39483
39484 struct ENDCX2RemovalFailure : asn::sequence<1, 0, true, 0>
39485 {
39486         static constexpr const char* name() {return "ENDCX2RemovalFailure";}
39487         using parent_t = asn::sequence<1, 0, true, 0>;
39488         struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalFailure_IEs>
39489         {
39490                 static constexpr const char* name() {return "protocolIEs_t";}
39491                 using parent_t = ProtocolIE_Container<ENDCX2RemovalFailure_IEs>;
39492
39493         };
39494         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
39495         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
39496         template<typename V> void decode(V& v)
39497         {
39498                 v(protocolIEs);
39499
39500         };
39501         template<typename V> void encode(V& v) const
39502         {
39503                 v(protocolIEs);
39504
39505         };
39506         void clear()
39507         {
39508                 protocolIEs.clear();
39509
39510         };
39511         private:
39512         protocolIEs_t   protocolIEs;
39513
39514 };
39515 /*
39516 En-gNB-ENDCX2RemovalReqIEs X2AP-PROTOCOL-IES ::= {
39517         { ID id-Globalen-gNB-ID                                                 CRITICALITY reject      TYPE GlobalGNB-ID                                                                               PRESENCE mandatory},
39518         ...
39519 }
39520 */
39521
39522 struct En_gNB_ENDCX2RemovalReqIEs
39523 {
39524         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39525         {
39526                 size_t get_index() const {return type;}
39527                 bool is_unknown() const { return type == 2; }
39528                 void clear() {type = 0;}
39529                 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
39530                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39531                 template<typename V>  bool decode(V& v)
39532                 {
39533                         clear();
39534                         if(!v(ref_nested())) return false;
39535                         if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
39536                         else { type = 2; return true;}
39537                         return false;
39538
39539                 }
39540                 template<typename V> bool encode(V& v) const
39541                 {
39542                         return v(ref_nested());
39543
39544                 }
39545                 protected:
39546                 template<typename V>  bool decode(size_t index, V& v)
39547                 {
39548                         clear();
39549                         switch(index)
39550                         {
39551                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
39552                         case 2: type = 2; return v(ref_nested());
39553                         ref_nested().clear();
39554                         }
39555                         return false;
39556
39557                 }
39558                 template<typename V> bool encode(size_t index, V& v) const
39559                 {
39560                         if(index != type) {return false;} return v(ref_nested());
39561
39562                 }
39563                 private:
39564                 size_t type {0};
39565
39566         };
39567         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39568         {
39569                 size_t get_index() const {return type;}
39570                 bool is_unknown() const { return type == 2; }
39571                 void clear() {type = 0;}
39572                 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
39573                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39574                 template<typename V>  bool decode(V& v)
39575                 {
39576                         clear();
39577                         if(!v(ref_nested())) return false;
39578                         if(equal(reject)) { type = 1; return true; }
39579                         else { type = 2; return true;}
39580                         return false;
39581
39582                 }
39583                 template<typename V> bool encode(V& v) const
39584                 {
39585                         return v(ref_nested());
39586
39587                 }
39588                 protected:
39589                 template<typename V>  bool decode(size_t index, V& v)
39590                 {
39591                         clear();
39592                         switch(index)
39593                         {
39594                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39595                         case 2: type = 2; return v(ref_nested());
39596                         ref_nested().clear();
39597                         }
39598                         return false;
39599
39600                 }
39601                 template<typename V> bool encode(size_t index, V& v) const
39602                 {
39603                         if(index != type) {return false;} return v(ref_nested());
39604
39605                 }
39606                 private:
39607                 size_t type {0};
39608
39609         };
39610         struct Value_t : asn::typefield<true>
39611         {
39612                 ~Value_t()      {clear();}
39613                 size_t get_index() const {return type;}
39614                 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
39615                 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
39616                 bool is_unknown() const { return type == 2; }
39617                 void clear()
39618                 {
39619                         switch(type)
39620                         {
39621                         case 1: var.destroy<GlobalGNB_ID>(); break;
39622                         }
39623                         type = 0; ref_nested().clear();
39624                 }
39625                 template<typename V> static inline void enumerate(V& v)
39626                 {
39627                         v.template operator()<GlobalGNB_ID>(1);
39628
39629                 }
39630                 protected:
39631                 template<typename V> bool decode(size_t index, V& v)
39632                 {
39633                         clear();
39634                         switch(index)
39635                         {
39636                         case 1: v(select_id_Globalen_gNB_ID()); return true;
39637                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
39638                         }
39639                         return false;
39640
39641                 }
39642                 template<typename V> bool encode(size_t index, V& v) const
39643                 {
39644                         if(index != type) return false;
39645                         switch(type)
39646                         {
39647                         case 1: v(var.as<GlobalGNB_ID>()); return true;
39648                         }
39649                         return false;
39650
39651                 }
39652                 private:
39653                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39654                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39655                 union union_type
39656                 {
39657                         char dummy1[sizeof(GlobalGNB_ID)];
39658
39659                 };
39660                 asn::variant<sizeof(union_type)> var;
39661                 size_t type {0};
39662
39663         };
39664         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39665         {
39666                 size_t get_index() const {return type;}
39667                 bool is_unknown() const { return type == 2; }
39668                 void clear() {type = 0;}
39669                 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
39670                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39671                 template<typename V>  bool decode(V& v)
39672                 {
39673                         clear();
39674                         if(!v(ref_nested())) return false;
39675                         if(equal(mandatory)) { type = 1; return true; }
39676                         else { type = 2; return true;}
39677                         return false;
39678
39679                 }
39680                 template<typename V> bool encode(V& v) const
39681                 {
39682                         return v(ref_nested());
39683
39684                 }
39685                 protected:
39686                 template<typename V>  bool decode(size_t index, V& v)
39687                 {
39688                         clear();
39689                         switch(index)
39690                         {
39691                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39692                         case 2: type = 2; return v(ref_nested());
39693                         ref_nested().clear();
39694                         }
39695                         return false;
39696
39697                 }
39698                 template<typename V> bool encode(size_t index, V& v) const
39699                 {
39700                         if(index != type) {return false;} return v(ref_nested());
39701
39702                 }
39703                 private:
39704                 size_t type {0};
39705
39706         };
39707
39708 };
39709 /*
39710 InitiatingNodeType-EndcX2Removal ::= CHOICE {
39711         init-eNB                                ProtocolIE-Container    {{ENB-ENDCX2RemovalReqIEs}},
39712         init-en-gNB                     ProtocolIE-Container    {{En-gNB-ENDCX2RemovalReqIEs}},
39713         ...
39714 }
39715 */
39716
39717 struct InitiatingNodeType_EndcX2Removal : asn::choice<2, 0, true>
39718 {
39719         static constexpr const char* name() {return "InitiatingNodeType-EndcX2Removal";}
39720         using parent_t = asn::choice<2, 0, true>;
39721         index_type get_index() const {return index;}
39722         bool is_unknown() const {return index == 3;}
39723         void set_unknown() { set_index(3);  }
39724         ~InitiatingNodeType_EndcX2Removal() {clear();}
39725         struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>
39726         {
39727                 static constexpr const char* name() {return "init_eNB_t";}
39728                 using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqIEs>;
39729
39730         };
39731         struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>
39732         {
39733                 static constexpr const char* name() {return "init_en_gNB_t";}
39734                 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqIEs>;
39735
39736         };
39737         void clear()
39738         {
39739                 switch(get_index())
39740                 {
39741                 case 1: var.destroy<init_eNB_t>(); break;
39742                 case 2: var.destroy<init_en_gNB_t>(); break;
39743                 }
39744                 index = 0;
39745                 base::clear();
39746         }
39747         template<typename V> bool decode(size_t idx, V& v)
39748         {
39749                 clear();
39750                 switch(idx)
39751                 {
39752                 case 1: set_index(1); return v(var.build<init_eNB_t>());
39753                 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
39754                 }
39755                 return false;
39756
39757         }
39758         template<typename V> bool encode(V& v) const
39759         {
39760                 switch(get_index())
39761                 {
39762                 case 1: return v(var.as<init_eNB_t>());
39763                 case 2: return v(var.as<init_en_gNB_t>());
39764                 }
39765                 return false;
39766         }
39767         template<typename V> static inline void enumerate(V& v)
39768         {
39769                 v.template operator()<init_eNB_t>(1);
39770                 v.template operator()<init_en_gNB_t>(2);
39771
39772         }
39773         init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
39774         init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
39775         init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
39776         init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
39777         private:
39778         void set_index(index_type i) {index = i; base::set();}
39779         union union_type
39780         {
39781                 char dummy1[sizeof(init_eNB_t)];
39782                 char dummy2[sizeof(init_en_gNB_t)];
39783
39784         };
39785         asn::variant<sizeof(union_type)>        var;
39786         index_type      index {0};
39787 };
39788 /*
39789 ENDCX2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
39790         { ID id-InitiatingNodeType-EndcX2Removal                        CRITICALITY reject      TYPE InitiatingNodeType-EndcX2Removal           PRESENCE mandatory},
39791         ...
39792 }
39793 */
39794
39795 struct ENDCX2RemovalRequest_IEs
39796 {
39797         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
39798         {
39799                 size_t get_index() const {return type;}
39800                 bool is_unknown() const { return type == 2; }
39801                 void clear() {type = 0;}
39802                 void select_id_InitiatingNodeType_EndcX2Removal() { set(id_InitiatingNodeType_EndcX2Removal); type=1;}
39803                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
39804                 template<typename V>  bool decode(V& v)
39805                 {
39806                         clear();
39807                         if(!v(ref_nested())) return false;
39808                         if(equal(id_InitiatingNodeType_EndcX2Removal)) { type = 1; return true; }
39809                         else { type = 2; return true;}
39810                         return false;
39811
39812                 }
39813                 template<typename V> bool encode(V& v) const
39814                 {
39815                         return v(ref_nested());
39816
39817                 }
39818                 protected:
39819                 template<typename V>  bool decode(size_t index, V& v)
39820                 {
39821                         clear();
39822                         switch(index)
39823                         {
39824                         case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcX2Removal);} return false;
39825                         case 2: type = 2; return v(ref_nested());
39826                         ref_nested().clear();
39827                         }
39828                         return false;
39829
39830                 }
39831                 template<typename V> bool encode(size_t index, V& v) const
39832                 {
39833                         if(index != type) {return false;} return v(ref_nested());
39834
39835                 }
39836                 private:
39837                 size_t type {0};
39838
39839         };
39840         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
39841         {
39842                 size_t get_index() const {return type;}
39843                 bool is_unknown() const { return type == 2; }
39844                 void clear() {type = 0;}
39845                 void select_id_InitiatingNodeType_EndcX2Removal() { set(reject); type=1;}
39846                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
39847                 template<typename V>  bool decode(V& v)
39848                 {
39849                         clear();
39850                         if(!v(ref_nested())) return false;
39851                         if(equal(reject)) { type = 1; return true; }
39852                         else { type = 2; return true;}
39853                         return false;
39854
39855                 }
39856                 template<typename V> bool encode(V& v) const
39857                 {
39858                         return v(ref_nested());
39859
39860                 }
39861                 protected:
39862                 template<typename V>  bool decode(size_t index, V& v)
39863                 {
39864                         clear();
39865                         switch(index)
39866                         {
39867                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
39868                         case 2: type = 2; return v(ref_nested());
39869                         ref_nested().clear();
39870                         }
39871                         return false;
39872
39873                 }
39874                 template<typename V> bool encode(size_t index, V& v) const
39875                 {
39876                         if(index != type) {return false;} return v(ref_nested());
39877
39878                 }
39879                 private:
39880                 size_t type {0};
39881
39882         };
39883         struct Value_t : asn::typefield<true>
39884         {
39885                 ~Value_t()      {clear();}
39886                 size_t get_index() const {return type;}
39887                 InitiatingNodeType_EndcX2Removal& select_id_InitiatingNodeType_EndcX2Removal() { return set<InitiatingNodeType_EndcX2Removal>(1); }
39888                 InitiatingNodeType_EndcX2Removal const* get_id_InitiatingNodeType_EndcX2Removal() const { return get<InitiatingNodeType_EndcX2Removal>(1); }
39889                 bool is_unknown() const { return type == 2; }
39890                 void clear()
39891                 {
39892                         switch(type)
39893                         {
39894                         case 1: var.destroy<InitiatingNodeType_EndcX2Removal>(); break;
39895                         }
39896                         type = 0; ref_nested().clear();
39897                 }
39898                 template<typename V> static inline void enumerate(V& v)
39899                 {
39900                         v.template operator()<InitiatingNodeType_EndcX2Removal>(1);
39901
39902                 }
39903                 protected:
39904                 template<typename V> bool decode(size_t index, V& v)
39905                 {
39906                         clear();
39907                         switch(index)
39908                         {
39909                         case 1: v(select_id_InitiatingNodeType_EndcX2Removal()); return true;
39910                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
39911                         }
39912                         return false;
39913
39914                 }
39915                 template<typename V> bool encode(size_t index, V& v) const
39916                 {
39917                         if(index != type) return false;
39918                         switch(type)
39919                         {
39920                         case 1: v(var.as<InitiatingNodeType_EndcX2Removal>()); return true;
39921                         }
39922                         return false;
39923
39924                 }
39925                 private:
39926                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
39927                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
39928                 union union_type
39929                 {
39930                         char dummy1[sizeof(InitiatingNodeType_EndcX2Removal)];
39931
39932                 };
39933                 asn::variant<sizeof(union_type)> var;
39934                 size_t type {0};
39935
39936         };
39937         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
39938         {
39939                 size_t get_index() const {return type;}
39940                 bool is_unknown() const { return type == 2; }
39941                 void clear() {type = 0;}
39942                 void select_id_InitiatingNodeType_EndcX2Removal() { set(mandatory); type=1;}
39943                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
39944                 template<typename V>  bool decode(V& v)
39945                 {
39946                         clear();
39947                         if(!v(ref_nested())) return false;
39948                         if(equal(mandatory)) { type = 1; return true; }
39949                         else { type = 2; return true;}
39950                         return false;
39951
39952                 }
39953                 template<typename V> bool encode(V& v) const
39954                 {
39955                         return v(ref_nested());
39956
39957                 }
39958                 protected:
39959                 template<typename V>  bool decode(size_t index, V& v)
39960                 {
39961                         clear();
39962                         switch(index)
39963                         {
39964                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
39965                         case 2: type = 2; return v(ref_nested());
39966                         ref_nested().clear();
39967                         }
39968                         return false;
39969
39970                 }
39971                 template<typename V> bool encode(size_t index, V& v) const
39972                 {
39973                         if(index != type) {return false;} return v(ref_nested());
39974
39975                 }
39976                 private:
39977                 size_t type {0};
39978
39979         };
39980
39981 };
39982 /*
39983 ENDCX2RemovalRequest ::= SEQUENCE {
39984         protocolIEs             ProtocolIE-Container    {{ENDCX2RemovalRequest-IEs}},
39985         ...
39986 }
39987 */
39988
39989 struct ENDCX2RemovalRequest : asn::sequence<1, 0, true, 0>
39990 {
39991         static constexpr const char* name() {return "ENDCX2RemovalRequest";}
39992         using parent_t = asn::sequence<1, 0, true, 0>;
39993         struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalRequest_IEs>
39994         {
39995                 static constexpr const char* name() {return "protocolIEs_t";}
39996                 using parent_t = ProtocolIE_Container<ENDCX2RemovalRequest_IEs>;
39997
39998         };
39999         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40000         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40001         template<typename V> void decode(V& v)
40002         {
40003                 v(protocolIEs);
40004
40005         };
40006         template<typename V> void encode(V& v) const
40007         {
40008                 v(protocolIEs);
40009
40010         };
40011         void clear()
40012         {
40013                 protocolIEs.clear();
40014
40015         };
40016         private:
40017         protocolIEs_t   protocolIEs;
40018
40019 };
40020 /*
40021 En-gNB-ENDCX2RemovalReqAckIEs X2AP-PROTOCOL-IES ::= {
40022         { ID id-Globalen-gNB-ID                                                 CRITICALITY reject      TYPE GlobalGNB-ID                                                                               PRESENCE mandatory},
40023         ...
40024 }
40025 */
40026
40027 struct En_gNB_ENDCX2RemovalReqAckIEs
40028 {
40029         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40030         {
40031                 size_t get_index() const {return type;}
40032                 bool is_unknown() const { return type == 2; }
40033                 void clear() {type = 0;}
40034                 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
40035                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40036                 template<typename V>  bool decode(V& v)
40037                 {
40038                         clear();
40039                         if(!v(ref_nested())) return false;
40040                         if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
40041                         else { type = 2; return true;}
40042                         return false;
40043
40044                 }
40045                 template<typename V> bool encode(V& v) const
40046                 {
40047                         return v(ref_nested());
40048
40049                 }
40050                 protected:
40051                 template<typename V>  bool decode(size_t index, V& v)
40052                 {
40053                         clear();
40054                         switch(index)
40055                         {
40056                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
40057                         case 2: type = 2; return v(ref_nested());
40058                         ref_nested().clear();
40059                         }
40060                         return false;
40061
40062                 }
40063                 template<typename V> bool encode(size_t index, V& v) const
40064                 {
40065                         if(index != type) {return false;} return v(ref_nested());
40066
40067                 }
40068                 private:
40069                 size_t type {0};
40070
40071         };
40072         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40073         {
40074                 size_t get_index() const {return type;}
40075                 bool is_unknown() const { return type == 2; }
40076                 void clear() {type = 0;}
40077                 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
40078                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40079                 template<typename V>  bool decode(V& v)
40080                 {
40081                         clear();
40082                         if(!v(ref_nested())) return false;
40083                         if(equal(reject)) { type = 1; return true; }
40084                         else { type = 2; return true;}
40085                         return false;
40086
40087                 }
40088                 template<typename V> bool encode(V& v) const
40089                 {
40090                         return v(ref_nested());
40091
40092                 }
40093                 protected:
40094                 template<typename V>  bool decode(size_t index, V& v)
40095                 {
40096                         clear();
40097                         switch(index)
40098                         {
40099                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40100                         case 2: type = 2; return v(ref_nested());
40101                         ref_nested().clear();
40102                         }
40103                         return false;
40104
40105                 }
40106                 template<typename V> bool encode(size_t index, V& v) const
40107                 {
40108                         if(index != type) {return false;} return v(ref_nested());
40109
40110                 }
40111                 private:
40112                 size_t type {0};
40113
40114         };
40115         struct Value_t : asn::typefield<true>
40116         {
40117                 ~Value_t()      {clear();}
40118                 size_t get_index() const {return type;}
40119                 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
40120                 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
40121                 bool is_unknown() const { return type == 2; }
40122                 void clear()
40123                 {
40124                         switch(type)
40125                         {
40126                         case 1: var.destroy<GlobalGNB_ID>(); break;
40127                         }
40128                         type = 0; ref_nested().clear();
40129                 }
40130                 template<typename V> static inline void enumerate(V& v)
40131                 {
40132                         v.template operator()<GlobalGNB_ID>(1);
40133
40134                 }
40135                 protected:
40136                 template<typename V> bool decode(size_t index, V& v)
40137                 {
40138                         clear();
40139                         switch(index)
40140                         {
40141                         case 1: v(select_id_Globalen_gNB_ID()); return true;
40142                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
40143                         }
40144                         return false;
40145
40146                 }
40147                 template<typename V> bool encode(size_t index, V& v) const
40148                 {
40149                         if(index != type) return false;
40150                         switch(type)
40151                         {
40152                         case 1: v(var.as<GlobalGNB_ID>()); return true;
40153                         }
40154                         return false;
40155
40156                 }
40157                 private:
40158                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40159                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40160                 union union_type
40161                 {
40162                         char dummy1[sizeof(GlobalGNB_ID)];
40163
40164                 };
40165                 asn::variant<sizeof(union_type)> var;
40166                 size_t type {0};
40167
40168         };
40169         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40170         {
40171                 size_t get_index() const {return type;}
40172                 bool is_unknown() const { return type == 2; }
40173                 void clear() {type = 0;}
40174                 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
40175                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40176                 template<typename V>  bool decode(V& v)
40177                 {
40178                         clear();
40179                         if(!v(ref_nested())) return false;
40180                         if(equal(mandatory)) { type = 1; return true; }
40181                         else { type = 2; return true;}
40182                         return false;
40183
40184                 }
40185                 template<typename V> bool encode(V& v) const
40186                 {
40187                         return v(ref_nested());
40188
40189                 }
40190                 protected:
40191                 template<typename V>  bool decode(size_t index, V& v)
40192                 {
40193                         clear();
40194                         switch(index)
40195                         {
40196                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40197                         case 2: type = 2; return v(ref_nested());
40198                         ref_nested().clear();
40199                         }
40200                         return false;
40201
40202                 }
40203                 template<typename V> bool encode(size_t index, V& v) const
40204                 {
40205                         if(index != type) {return false;} return v(ref_nested());
40206
40207                 }
40208                 private:
40209                 size_t type {0};
40210
40211         };
40212
40213 };
40214 /*
40215 RespondingNodeType-EndcX2Removal ::= CHOICE {
40216         respond-eNB                     ProtocolIE-Container    {{ENB-ENDCX2RemovalReqAckIEs}},
40217         respond-en-gNB          ProtocolIE-Container    {{En-gNB-ENDCX2RemovalReqAckIEs}},
40218         ...
40219 }
40220 */
40221
40222 struct RespondingNodeType_EndcX2Removal : asn::choice<2, 0, true>
40223 {
40224         static constexpr const char* name() {return "RespondingNodeType-EndcX2Removal";}
40225         using parent_t = asn::choice<2, 0, true>;
40226         index_type get_index() const {return index;}
40227         bool is_unknown() const {return index == 3;}
40228         void set_unknown() { set_index(3);  }
40229         ~RespondingNodeType_EndcX2Removal() {clear();}
40230         struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>
40231         {
40232                 static constexpr const char* name() {return "respond_eNB_t";}
40233                 using parent_t = ProtocolIE_Container<ENB_ENDCX2RemovalReqAckIEs>;
40234
40235         };
40236         struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>
40237         {
40238                 static constexpr const char* name() {return "respond_en_gNB_t";}
40239                 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2RemovalReqAckIEs>;
40240
40241         };
40242         void clear()
40243         {
40244                 switch(get_index())
40245                 {
40246                 case 1: var.destroy<respond_eNB_t>(); break;
40247                 case 2: var.destroy<respond_en_gNB_t>(); break;
40248                 }
40249                 index = 0;
40250                 base::clear();
40251         }
40252         template<typename V> bool decode(size_t idx, V& v)
40253         {
40254                 clear();
40255                 switch(idx)
40256                 {
40257                 case 1: set_index(1); return v(var.build<respond_eNB_t>());
40258                 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
40259                 }
40260                 return false;
40261
40262         }
40263         template<typename V> bool encode(V& v) const
40264         {
40265                 switch(get_index())
40266                 {
40267                 case 1: return v(var.as<respond_eNB_t>());
40268                 case 2: return v(var.as<respond_en_gNB_t>());
40269                 }
40270                 return false;
40271         }
40272         template<typename V> static inline void enumerate(V& v)
40273         {
40274                 v.template operator()<respond_eNB_t>(1);
40275                 v.template operator()<respond_en_gNB_t>(2);
40276
40277         }
40278         respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
40279         respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
40280         respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
40281         respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
40282         private:
40283         void set_index(index_type i) {index = i; base::set();}
40284         union union_type
40285         {
40286                 char dummy1[sizeof(respond_eNB_t)];
40287                 char dummy2[sizeof(respond_en_gNB_t)];
40288
40289         };
40290         asn::variant<sizeof(union_type)>        var;
40291         index_type      index {0};
40292 };
40293 /*
40294 ENDCX2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
40295         { ID id-RespondingNodeType-EndcX2Removal                CRITICALITY reject      TYPE RespondingNodeType-EndcX2Removal           PRESENCE mandatory},
40296         ...
40297 }
40298 */
40299
40300 struct ENDCX2RemovalResponse_IEs
40301 {
40302         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40303         {
40304                 size_t get_index() const {return type;}
40305                 bool is_unknown() const { return type == 2; }
40306                 void clear() {type = 0;}
40307                 void select_id_RespondingNodeType_EndcX2Removal() { set(id_RespondingNodeType_EndcX2Removal); type=1;}
40308                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40309                 template<typename V>  bool decode(V& v)
40310                 {
40311                         clear();
40312                         if(!v(ref_nested())) return false;
40313                         if(equal(id_RespondingNodeType_EndcX2Removal)) { type = 1; return true; }
40314                         else { type = 2; return true;}
40315                         return false;
40316
40317                 }
40318                 template<typename V> bool encode(V& v) const
40319                 {
40320                         return v(ref_nested());
40321
40322                 }
40323                 protected:
40324                 template<typename V>  bool decode(size_t index, V& v)
40325                 {
40326                         clear();
40327                         switch(index)
40328                         {
40329                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcX2Removal);} return false;
40330                         case 2: type = 2; return v(ref_nested());
40331                         ref_nested().clear();
40332                         }
40333                         return false;
40334
40335                 }
40336                 template<typename V> bool encode(size_t index, V& v) const
40337                 {
40338                         if(index != type) {return false;} return v(ref_nested());
40339
40340                 }
40341                 private:
40342                 size_t type {0};
40343
40344         };
40345         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40346         {
40347                 size_t get_index() const {return type;}
40348                 bool is_unknown() const { return type == 2; }
40349                 void clear() {type = 0;}
40350                 void select_id_RespondingNodeType_EndcX2Removal() { set(reject); type=1;}
40351                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40352                 template<typename V>  bool decode(V& v)
40353                 {
40354                         clear();
40355                         if(!v(ref_nested())) return false;
40356                         if(equal(reject)) { type = 1; return true; }
40357                         else { type = 2; return true;}
40358                         return false;
40359
40360                 }
40361                 template<typename V> bool encode(V& v) const
40362                 {
40363                         return v(ref_nested());
40364
40365                 }
40366                 protected:
40367                 template<typename V>  bool decode(size_t index, V& v)
40368                 {
40369                         clear();
40370                         switch(index)
40371                         {
40372                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40373                         case 2: type = 2; return v(ref_nested());
40374                         ref_nested().clear();
40375                         }
40376                         return false;
40377
40378                 }
40379                 template<typename V> bool encode(size_t index, V& v) const
40380                 {
40381                         if(index != type) {return false;} return v(ref_nested());
40382
40383                 }
40384                 private:
40385                 size_t type {0};
40386
40387         };
40388         struct Value_t : asn::typefield<true>
40389         {
40390                 ~Value_t()      {clear();}
40391                 size_t get_index() const {return type;}
40392                 RespondingNodeType_EndcX2Removal& select_id_RespondingNodeType_EndcX2Removal() { return set<RespondingNodeType_EndcX2Removal>(1); }
40393                 RespondingNodeType_EndcX2Removal const* get_id_RespondingNodeType_EndcX2Removal() const { return get<RespondingNodeType_EndcX2Removal>(1); }
40394                 bool is_unknown() const { return type == 2; }
40395                 void clear()
40396                 {
40397                         switch(type)
40398                         {
40399                         case 1: var.destroy<RespondingNodeType_EndcX2Removal>(); break;
40400                         }
40401                         type = 0; ref_nested().clear();
40402                 }
40403                 template<typename V> static inline void enumerate(V& v)
40404                 {
40405                         v.template operator()<RespondingNodeType_EndcX2Removal>(1);
40406
40407                 }
40408                 protected:
40409                 template<typename V> bool decode(size_t index, V& v)
40410                 {
40411                         clear();
40412                         switch(index)
40413                         {
40414                         case 1: v(select_id_RespondingNodeType_EndcX2Removal()); return true;
40415                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
40416                         }
40417                         return false;
40418
40419                 }
40420                 template<typename V> bool encode(size_t index, V& v) const
40421                 {
40422                         if(index != type) return false;
40423                         switch(type)
40424                         {
40425                         case 1: v(var.as<RespondingNodeType_EndcX2Removal>()); return true;
40426                         }
40427                         return false;
40428
40429                 }
40430                 private:
40431                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40432                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40433                 union union_type
40434                 {
40435                         char dummy1[sizeof(RespondingNodeType_EndcX2Removal)];
40436
40437                 };
40438                 asn::variant<sizeof(union_type)> var;
40439                 size_t type {0};
40440
40441         };
40442         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40443         {
40444                 size_t get_index() const {return type;}
40445                 bool is_unknown() const { return type == 2; }
40446                 void clear() {type = 0;}
40447                 void select_id_RespondingNodeType_EndcX2Removal() { set(mandatory); type=1;}
40448                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40449                 template<typename V>  bool decode(V& v)
40450                 {
40451                         clear();
40452                         if(!v(ref_nested())) return false;
40453                         if(equal(mandatory)) { type = 1; return true; }
40454                         else { type = 2; return true;}
40455                         return false;
40456
40457                 }
40458                 template<typename V> bool encode(V& v) const
40459                 {
40460                         return v(ref_nested());
40461
40462                 }
40463                 protected:
40464                 template<typename V>  bool decode(size_t index, V& v)
40465                 {
40466                         clear();
40467                         switch(index)
40468                         {
40469                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40470                         case 2: type = 2; return v(ref_nested());
40471                         ref_nested().clear();
40472                         }
40473                         return false;
40474
40475                 }
40476                 template<typename V> bool encode(size_t index, V& v) const
40477                 {
40478                         if(index != type) {return false;} return v(ref_nested());
40479
40480                 }
40481                 private:
40482                 size_t type {0};
40483
40484         };
40485
40486 };
40487 /*
40488 ENDCX2RemovalResponse ::= SEQUENCE {
40489         protocolIEs             ProtocolIE-Container    {{ENDCX2RemovalResponse-IEs}},
40490         ...
40491 }
40492 */
40493
40494 struct ENDCX2RemovalResponse : asn::sequence<1, 0, true, 0>
40495 {
40496         static constexpr const char* name() {return "ENDCX2RemovalResponse";}
40497         using parent_t = asn::sequence<1, 0, true, 0>;
40498         struct protocolIEs_t : ProtocolIE_Container<ENDCX2RemovalResponse_IEs>
40499         {
40500                 static constexpr const char* name() {return "protocolIEs_t";}
40501                 using parent_t = ProtocolIE_Container<ENDCX2RemovalResponse_IEs>;
40502
40503         };
40504         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40505         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40506         template<typename V> void decode(V& v)
40507         {
40508                 v(protocolIEs);
40509
40510         };
40511         template<typename V> void encode(V& v) const
40512         {
40513                 v(protocolIEs);
40514
40515         };
40516         void clear()
40517         {
40518                 protocolIEs.clear();
40519
40520         };
40521         private:
40522         protocolIEs_t   protocolIEs;
40523
40524 };
40525 /*
40526 ENDCX2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
40527         { ID id-Cause                                   CRITICALITY ignore              TYPE Cause                                                              PRESENCE mandatory} |
40528         { ID id-CriticalityDiagnostics  CRITICALITY ignore              TYPE CriticalityDiagnostics                             PRESENCE optional } |
40529         { ID id-TimeToWait                              CRITICALITY ignore              TYPE TimeToWait                                                 PRESENCE optional       },
40530         ...
40531 }
40532 */
40533
40534 struct ENDCX2SetupFailure_IEs
40535 {
40536         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40537         {
40538                 size_t get_index() const {return type;}
40539                 bool is_unknown() const { return type == 4; }
40540                 void clear() {type = 0;}
40541                 void select_id_Cause() { set(id_Cause); type=1;}
40542                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
40543                 void select_id_TimeToWait() { set(id_TimeToWait); type=3;}
40544                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40545                 template<typename V>  bool decode(V& v)
40546                 {
40547                         clear();
40548                         if(!v(ref_nested())) return false;
40549                         if(equal(id_Cause)) { type = 1; return true; }
40550                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
40551                         else if(equal(id_TimeToWait)) { type = 3; return true; }
40552                         else { type = 4; return true;}
40553                         return false;
40554
40555                 }
40556                 template<typename V> bool encode(V& v) const
40557                 {
40558                         return v(ref_nested());
40559
40560                 }
40561                 protected:
40562                 template<typename V>  bool decode(size_t index, V& v)
40563                 {
40564                         clear();
40565                         switch(index)
40566                         {
40567                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
40568                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
40569                         case 3: type = 3; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
40570                         case 4: type = 4; return v(ref_nested());
40571                         ref_nested().clear();
40572                         }
40573                         return false;
40574
40575                 }
40576                 template<typename V> bool encode(size_t index, V& v) const
40577                 {
40578                         if(index != type) {return false;} return v(ref_nested());
40579
40580                 }
40581                 private:
40582                 size_t type {0};
40583
40584         };
40585         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40586         {
40587                 size_t get_index() const {return type;}
40588                 bool is_unknown() const { return type == 4; }
40589                 void clear() {type = 0;}
40590                 void select_id_Cause() { set(ignore); type=1;}
40591                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
40592                 void select_id_TimeToWait() { set(ignore); type=3;}
40593                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40594                 template<typename V>  bool decode(V& v)
40595                 {
40596                         clear();
40597                         if(!v(ref_nested())) return false;
40598                         if(equal(ignore)) { type = 1; return true; }
40599                         else if(equal(ignore)) { type = 2; return true; }
40600                         else if(equal(ignore)) { type = 3; return true; }
40601                         else { type = 4; return true;}
40602                         return false;
40603
40604                 }
40605                 template<typename V> bool encode(V& v) const
40606                 {
40607                         return v(ref_nested());
40608
40609                 }
40610                 protected:
40611                 template<typename V>  bool decode(size_t index, V& v)
40612                 {
40613                         clear();
40614                         switch(index)
40615                         {
40616                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
40617                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
40618                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
40619                         case 4: type = 4; return v(ref_nested());
40620                         ref_nested().clear();
40621                         }
40622                         return false;
40623
40624                 }
40625                 template<typename V> bool encode(size_t index, V& v) const
40626                 {
40627                         if(index != type) {return false;} return v(ref_nested());
40628
40629                 }
40630                 private:
40631                 size_t type {0};
40632
40633         };
40634         struct Value_t : asn::typefield<true>
40635         {
40636                 ~Value_t()      {clear();}
40637                 size_t get_index() const {return type;}
40638                 Cause& select_id_Cause() { return set<Cause>(1); }
40639                 Cause const* get_id_Cause() const { return get<Cause>(1); }
40640                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
40641                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
40642                 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(3); }
40643                 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(3); }
40644                 bool is_unknown() const { return type == 4; }
40645                 void clear()
40646                 {
40647                         switch(type)
40648                         {
40649                         case 1: var.destroy<Cause>(); break;
40650                         case 2: var.destroy<CriticalityDiagnostics>(); break;
40651                         case 3: var.destroy<TimeToWait>(); break;
40652                         }
40653                         type = 0; ref_nested().clear();
40654                 }
40655                 template<typename V> static inline void enumerate(V& v)
40656                 {
40657                         v.template operator()<Cause>(1);
40658                         v.template operator()<CriticalityDiagnostics>(2);
40659                         v.template operator()<TimeToWait>(3);
40660
40661                 }
40662                 protected:
40663                 template<typename V> bool decode(size_t index, V& v)
40664                 {
40665                         clear();
40666                         switch(index)
40667                         {
40668                         case 1: v(select_id_Cause()); return true;
40669                         case 2: v(select_id_CriticalityDiagnostics()); return true;
40670                         case 3: v(select_id_TimeToWait()); return true;
40671                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
40672                         }
40673                         return false;
40674
40675                 }
40676                 template<typename V> bool encode(size_t index, V& v) const
40677                 {
40678                         if(index != type) return false;
40679                         switch(type)
40680                         {
40681                         case 1: v(var.as<Cause>()); return true;
40682                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
40683                         case 3: v(var.as<TimeToWait>()); return true;
40684                         }
40685                         return false;
40686
40687                 }
40688                 private:
40689                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40690                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40691                 union union_type
40692                 {
40693                         char dummy1[sizeof(Cause)];
40694                         char dummy2[sizeof(CriticalityDiagnostics)];
40695                         char dummy3[sizeof(TimeToWait)];
40696
40697                 };
40698                 asn::variant<sizeof(union_type)> var;
40699                 size_t type {0};
40700
40701         };
40702         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40703         {
40704                 size_t get_index() const {return type;}
40705                 bool is_unknown() const { return type == 4; }
40706                 void clear() {type = 0;}
40707                 void select_id_Cause() { set(mandatory); type=1;}
40708                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
40709                 void select_id_TimeToWait() { set(optional); type=3;}
40710                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40711                 template<typename V>  bool decode(V& v)
40712                 {
40713                         clear();
40714                         if(!v(ref_nested())) return false;
40715                         if(equal(mandatory)) { type = 1; return true; }
40716                         else if(equal(optional)) { type = 2; return true; }
40717                         else if(equal(optional)) { type = 3; return true; }
40718                         else { type = 4; return true;}
40719                         return false;
40720
40721                 }
40722                 template<typename V> bool encode(V& v) const
40723                 {
40724                         return v(ref_nested());
40725
40726                 }
40727                 protected:
40728                 template<typename V>  bool decode(size_t index, V& v)
40729                 {
40730                         clear();
40731                         switch(index)
40732                         {
40733                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40734                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
40735                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
40736                         case 4: type = 4; return v(ref_nested());
40737                         ref_nested().clear();
40738                         }
40739                         return false;
40740
40741                 }
40742                 template<typename V> bool encode(size_t index, V& v) const
40743                 {
40744                         if(index != type) {return false;} return v(ref_nested());
40745
40746                 }
40747                 private:
40748                 size_t type {0};
40749
40750         };
40751
40752 };
40753 /*
40754 ENDCX2SetupFailure ::= SEQUENCE {
40755         protocolIEs             ProtocolIE-Container    {{ENDCX2SetupFailure-IEs}},
40756         ...
40757 }
40758 */
40759
40760 struct ENDCX2SetupFailure : asn::sequence<1, 0, true, 0>
40761 {
40762         static constexpr const char* name() {return "ENDCX2SetupFailure";}
40763         using parent_t = asn::sequence<1, 0, true, 0>;
40764         struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupFailure_IEs>
40765         {
40766                 static constexpr const char* name() {return "protocolIEs_t";}
40767                 using parent_t = ProtocolIE_Container<ENDCX2SetupFailure_IEs>;
40768
40769         };
40770         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
40771         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
40772         template<typename V> void decode(V& v)
40773         {
40774                 v(protocolIEs);
40775
40776         };
40777         template<typename V> void encode(V& v) const
40778         {
40779                 v(protocolIEs);
40780
40781         };
40782         void clear()
40783         {
40784                 protocolIEs.clear();
40785
40786         };
40787         private:
40788         protocolIEs_t   protocolIEs;
40789
40790 };
40791 /*
40792 En-gNB-ENDCX2SetupReqIEs X2AP-PROTOCOL-IES ::= {
40793         { ID id-Globalen-gNB-ID                                                 CRITICALITY reject      TYPE GlobalGNB-ID                                                                               PRESENCE mandatory}|
40794         { ID id-ServedNRcellsENDCX2ManagementList               CRITICALITY reject      TYPE ServedNRcellsENDCX2ManagementList                  PRESENCE mandatory},
40795         ...
40796 }
40797 */
40798
40799 struct En_gNB_ENDCX2SetupReqIEs
40800 {
40801         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
40802         {
40803                 size_t get_index() const {return type;}
40804                 bool is_unknown() const { return type == 3; }
40805                 void clear() {type = 0;}
40806                 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
40807                 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
40808                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
40809                 template<typename V>  bool decode(V& v)
40810                 {
40811                         clear();
40812                         if(!v(ref_nested())) return false;
40813                         if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
40814                         else if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 2; return true; }
40815                         else { type = 3; return true;}
40816                         return false;
40817
40818                 }
40819                 template<typename V> bool encode(V& v) const
40820                 {
40821                         return v(ref_nested());
40822
40823                 }
40824                 protected:
40825                 template<typename V>  bool decode(size_t index, V& v)
40826                 {
40827                         clear();
40828                         switch(index)
40829                         {
40830                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
40831                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
40832                         case 3: type = 3; return v(ref_nested());
40833                         ref_nested().clear();
40834                         }
40835                         return false;
40836
40837                 }
40838                 template<typename V> bool encode(size_t index, V& v) const
40839                 {
40840                         if(index != type) {return false;} return v(ref_nested());
40841
40842                 }
40843                 private:
40844                 size_t type {0};
40845
40846         };
40847         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
40848         {
40849                 size_t get_index() const {return type;}
40850                 bool is_unknown() const { return type == 3; }
40851                 void clear() {type = 0;}
40852                 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
40853                 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
40854                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
40855                 template<typename V>  bool decode(V& v)
40856                 {
40857                         clear();
40858                         if(!v(ref_nested())) return false;
40859                         if(equal(reject)) { type = 1; return true; }
40860                         else if(equal(reject)) { type = 2; return true; }
40861                         else { type = 3; return true;}
40862                         return false;
40863
40864                 }
40865                 template<typename V> bool encode(V& v) const
40866                 {
40867                         return v(ref_nested());
40868
40869                 }
40870                 protected:
40871                 template<typename V>  bool decode(size_t index, V& v)
40872                 {
40873                         clear();
40874                         switch(index)
40875                         {
40876                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
40877                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
40878                         case 3: type = 3; return v(ref_nested());
40879                         ref_nested().clear();
40880                         }
40881                         return false;
40882
40883                 }
40884                 template<typename V> bool encode(size_t index, V& v) const
40885                 {
40886                         if(index != type) {return false;} return v(ref_nested());
40887
40888                 }
40889                 private:
40890                 size_t type {0};
40891
40892         };
40893         struct Value_t : asn::typefield<true>
40894         {
40895                 ~Value_t()      {clear();}
40896                 size_t get_index() const {return type;}
40897                 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
40898                 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
40899                 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
40900                 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
40901                 bool is_unknown() const { return type == 3; }
40902                 void clear()
40903                 {
40904                         switch(type)
40905                         {
40906                         case 1: var.destroy<GlobalGNB_ID>(); break;
40907                         case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
40908                         }
40909                         type = 0; ref_nested().clear();
40910                 }
40911                 template<typename V> static inline void enumerate(V& v)
40912                 {
40913                         v.template operator()<GlobalGNB_ID>(1);
40914                         v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
40915
40916                 }
40917                 protected:
40918                 template<typename V> bool decode(size_t index, V& v)
40919                 {
40920                         clear();
40921                         switch(index)
40922                         {
40923                         case 1: v(select_id_Globalen_gNB_ID()); return true;
40924                         case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
40925                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
40926                         }
40927                         return false;
40928
40929                 }
40930                 template<typename V> bool encode(size_t index, V& v) const
40931                 {
40932                         if(index != type) return false;
40933                         switch(type)
40934                         {
40935                         case 1: v(var.as<GlobalGNB_ID>()); return true;
40936                         case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
40937                         }
40938                         return false;
40939
40940                 }
40941                 private:
40942                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
40943                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
40944                 union union_type
40945                 {
40946                         char dummy1[sizeof(GlobalGNB_ID)];
40947                         char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
40948
40949                 };
40950                 asn::variant<sizeof(union_type)> var;
40951                 size_t type {0};
40952
40953         };
40954         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
40955         {
40956                 size_t get_index() const {return type;}
40957                 bool is_unknown() const { return type == 3; }
40958                 void clear() {type = 0;}
40959                 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
40960                 void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
40961                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
40962                 template<typename V>  bool decode(V& v)
40963                 {
40964                         clear();
40965                         if(!v(ref_nested())) return false;
40966                         if(equal(mandatory)) { type = 1; return true; }
40967                         else if(equal(mandatory)) { type = 2; return true; }
40968                         else { type = 3; return true;}
40969                         return false;
40970
40971                 }
40972                 template<typename V> bool encode(V& v) const
40973                 {
40974                         return v(ref_nested());
40975
40976                 }
40977                 protected:
40978                 template<typename V>  bool decode(size_t index, V& v)
40979                 {
40980                         clear();
40981                         switch(index)
40982                         {
40983                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
40984                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
40985                         case 3: type = 3; return v(ref_nested());
40986                         ref_nested().clear();
40987                         }
40988                         return false;
40989
40990                 }
40991                 template<typename V> bool encode(size_t index, V& v) const
40992                 {
40993                         if(index != type) {return false;} return v(ref_nested());
40994
40995                 }
40996                 private:
40997                 size_t type {0};
40998
40999         };
41000
41001 };
41002 /*
41003 InitiatingNodeType-EndcX2Setup ::= CHOICE {
41004         init-eNB                                ProtocolIE-Container    {{ENB-ENDCX2SetupReqIEs}},
41005         init-en-gNB                     ProtocolIE-Container    {{En-gNB-ENDCX2SetupReqIEs}},
41006         ...
41007 }
41008 */
41009
41010 struct InitiatingNodeType_EndcX2Setup : asn::choice<2, 0, true>
41011 {
41012         static constexpr const char* name() {return "InitiatingNodeType-EndcX2Setup";}
41013         using parent_t = asn::choice<2, 0, true>;
41014         index_type get_index() const {return index;}
41015         bool is_unknown() const {return index == 3;}
41016         void set_unknown() { set_index(3);  }
41017         ~InitiatingNodeType_EndcX2Setup() {clear();}
41018         struct init_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>
41019         {
41020                 static constexpr const char* name() {return "init_eNB_t";}
41021                 using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>;
41022
41023         };
41024         struct init_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>
41025         {
41026                 static constexpr const char* name() {return "init_en_gNB_t";}
41027                 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqIEs>;
41028
41029         };
41030         void clear()
41031         {
41032                 switch(get_index())
41033                 {
41034                 case 1: var.destroy<init_eNB_t>(); break;
41035                 case 2: var.destroy<init_en_gNB_t>(); break;
41036                 }
41037                 index = 0;
41038                 base::clear();
41039         }
41040         template<typename V> bool decode(size_t idx, V& v)
41041         {
41042                 clear();
41043                 switch(idx)
41044                 {
41045                 case 1: set_index(1); return v(var.build<init_eNB_t>());
41046                 case 2: set_index(2); return v(var.build<init_en_gNB_t>());
41047                 }
41048                 return false;
41049
41050         }
41051         template<typename V> bool encode(V& v) const
41052         {
41053                 switch(get_index())
41054                 {
41055                 case 1: return v(var.as<init_eNB_t>());
41056                 case 2: return v(var.as<init_en_gNB_t>());
41057                 }
41058                 return false;
41059         }
41060         template<typename V> static inline void enumerate(V& v)
41061         {
41062                 v.template operator()<init_eNB_t>(1);
41063                 v.template operator()<init_en_gNB_t>(2);
41064
41065         }
41066         init_eNB_t& select_init_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<init_eNB_t>();} return var.as<init_eNB_t>();}
41067         init_eNB_t const* get_init_eNB() const { if(get_index() == 1) { return &var.as<init_eNB_t>();} return nullptr; }
41068         init_en_gNB_t& select_init_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<init_en_gNB_t>();} return var.as<init_en_gNB_t>();}
41069         init_en_gNB_t const* get_init_en_gNB() const { if(get_index() == 2) { return &var.as<init_en_gNB_t>();} return nullptr; }
41070         private:
41071         void set_index(index_type i) {index = i; base::set();}
41072         union union_type
41073         {
41074                 char dummy1[sizeof(init_eNB_t)];
41075                 char dummy2[sizeof(init_en_gNB_t)];
41076
41077         };
41078         asn::variant<sizeof(union_type)>        var;
41079         index_type      index {0};
41080 };
41081 /*
41082 ENDCX2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
41083         { ID id-InitiatingNodeType-EndcX2Setup                  CRITICALITY reject      TYPE InitiatingNodeType-EndcX2Setup             PRESENCE mandatory},
41084         ...
41085 }
41086 */
41087
41088 struct ENDCX2SetupRequest_IEs
41089 {
41090         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41091         {
41092                 size_t get_index() const {return type;}
41093                 bool is_unknown() const { return type == 2; }
41094                 void clear() {type = 0;}
41095                 void select_id_InitiatingNodeType_EndcX2Setup() { set(id_InitiatingNodeType_EndcX2Setup); type=1;}
41096                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41097                 template<typename V>  bool decode(V& v)
41098                 {
41099                         clear();
41100                         if(!v(ref_nested())) return false;
41101                         if(equal(id_InitiatingNodeType_EndcX2Setup)) { type = 1; return true; }
41102                         else { type = 2; return true;}
41103                         return false;
41104
41105                 }
41106                 template<typename V> bool encode(V& v) const
41107                 {
41108                         return v(ref_nested());
41109
41110                 }
41111                 protected:
41112                 template<typename V>  bool decode(size_t index, V& v)
41113                 {
41114                         clear();
41115                         switch(index)
41116                         {
41117                         case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EndcX2Setup);} return false;
41118                         case 2: type = 2; return v(ref_nested());
41119                         ref_nested().clear();
41120                         }
41121                         return false;
41122
41123                 }
41124                 template<typename V> bool encode(size_t index, V& v) const
41125                 {
41126                         if(index != type) {return false;} return v(ref_nested());
41127
41128                 }
41129                 private:
41130                 size_t type {0};
41131
41132         };
41133         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41134         {
41135                 size_t get_index() const {return type;}
41136                 bool is_unknown() const { return type == 2; }
41137                 void clear() {type = 0;}
41138                 void select_id_InitiatingNodeType_EndcX2Setup() { set(reject); type=1;}
41139                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41140                 template<typename V>  bool decode(V& v)
41141                 {
41142                         clear();
41143                         if(!v(ref_nested())) return false;
41144                         if(equal(reject)) { type = 1; return true; }
41145                         else { type = 2; return true;}
41146                         return false;
41147
41148                 }
41149                 template<typename V> bool encode(V& v) const
41150                 {
41151                         return v(ref_nested());
41152
41153                 }
41154                 protected:
41155                 template<typename V>  bool decode(size_t index, V& v)
41156                 {
41157                         clear();
41158                         switch(index)
41159                         {
41160                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41161                         case 2: type = 2; return v(ref_nested());
41162                         ref_nested().clear();
41163                         }
41164                         return false;
41165
41166                 }
41167                 template<typename V> bool encode(size_t index, V& v) const
41168                 {
41169                         if(index != type) {return false;} return v(ref_nested());
41170
41171                 }
41172                 private:
41173                 size_t type {0};
41174
41175         };
41176         struct Value_t : asn::typefield<true>
41177         {
41178                 ~Value_t()      {clear();}
41179                 size_t get_index() const {return type;}
41180                 InitiatingNodeType_EndcX2Setup& select_id_InitiatingNodeType_EndcX2Setup() { return set<InitiatingNodeType_EndcX2Setup>(1); }
41181                 InitiatingNodeType_EndcX2Setup const* get_id_InitiatingNodeType_EndcX2Setup() const { return get<InitiatingNodeType_EndcX2Setup>(1); }
41182                 bool is_unknown() const { return type == 2; }
41183                 void clear()
41184                 {
41185                         switch(type)
41186                         {
41187                         case 1: var.destroy<InitiatingNodeType_EndcX2Setup>(); break;
41188                         }
41189                         type = 0; ref_nested().clear();
41190                 }
41191                 template<typename V> static inline void enumerate(V& v)
41192                 {
41193                         v.template operator()<InitiatingNodeType_EndcX2Setup>(1);
41194
41195                 }
41196                 protected:
41197                 template<typename V> bool decode(size_t index, V& v)
41198                 {
41199                         clear();
41200                         switch(index)
41201                         {
41202                         case 1: v(select_id_InitiatingNodeType_EndcX2Setup()); return true;
41203                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
41204                         }
41205                         return false;
41206
41207                 }
41208                 template<typename V> bool encode(size_t index, V& v) const
41209                 {
41210                         if(index != type) return false;
41211                         switch(type)
41212                         {
41213                         case 1: v(var.as<InitiatingNodeType_EndcX2Setup>()); return true;
41214                         }
41215                         return false;
41216
41217                 }
41218                 private:
41219                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41220                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41221                 union union_type
41222                 {
41223                         char dummy1[sizeof(InitiatingNodeType_EndcX2Setup)];
41224
41225                 };
41226                 asn::variant<sizeof(union_type)> var;
41227                 size_t type {0};
41228
41229         };
41230         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41231         {
41232                 size_t get_index() const {return type;}
41233                 bool is_unknown() const { return type == 2; }
41234                 void clear() {type = 0;}
41235                 void select_id_InitiatingNodeType_EndcX2Setup() { set(mandatory); type=1;}
41236                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41237                 template<typename V>  bool decode(V& v)
41238                 {
41239                         clear();
41240                         if(!v(ref_nested())) return false;
41241                         if(equal(mandatory)) { type = 1; return true; }
41242                         else { type = 2; return true;}
41243                         return false;
41244
41245                 }
41246                 template<typename V> bool encode(V& v) const
41247                 {
41248                         return v(ref_nested());
41249
41250                 }
41251                 protected:
41252                 template<typename V>  bool decode(size_t index, V& v)
41253                 {
41254                         clear();
41255                         switch(index)
41256                         {
41257                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41258                         case 2: type = 2; return v(ref_nested());
41259                         ref_nested().clear();
41260                         }
41261                         return false;
41262
41263                 }
41264                 template<typename V> bool encode(size_t index, V& v) const
41265                 {
41266                         if(index != type) {return false;} return v(ref_nested());
41267
41268                 }
41269                 private:
41270                 size_t type {0};
41271
41272         };
41273
41274 };
41275 /*
41276 ENDCX2SetupRequest ::= SEQUENCE {
41277         protocolIEs             ProtocolIE-Container    {{ENDCX2SetupRequest-IEs}},
41278         ...
41279 }
41280 */
41281
41282 struct ENDCX2SetupRequest : asn::sequence<1, 0, true, 0>
41283 {
41284         static constexpr const char* name() {return "ENDCX2SetupRequest";}
41285         using parent_t = asn::sequence<1, 0, true, 0>;
41286         struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupRequest_IEs>
41287         {
41288                 static constexpr const char* name() {return "protocolIEs_t";}
41289                 using parent_t = ProtocolIE_Container<ENDCX2SetupRequest_IEs>;
41290
41291         };
41292         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
41293         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
41294         template<typename V> void decode(V& v)
41295         {
41296                 v(protocolIEs);
41297
41298         };
41299         template<typename V> void encode(V& v) const
41300         {
41301                 v(protocolIEs);
41302
41303         };
41304         void clear()
41305         {
41306                 protocolIEs.clear();
41307
41308         };
41309         private:
41310         protocolIEs_t   protocolIEs;
41311
41312 };
41313 /*
41314 En-gNB-ENDCX2SetupReqAckIEs X2AP-PROTOCOL-IES ::= {
41315         { ID id-Globalen-gNB-ID                                                 CRITICALITY reject      TYPE GlobalGNB-ID                                                                               PRESENCE mandatory}|
41316         { ID id-ServedNRcellsENDCX2ManagementList               CRITICALITY reject      TYPE ServedNRcellsENDCX2ManagementList                  PRESENCE mandatory},
41317         ...
41318 }
41319 */
41320
41321 struct En_gNB_ENDCX2SetupReqAckIEs
41322 {
41323         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41324         {
41325                 size_t get_index() const {return type;}
41326                 bool is_unknown() const { return type == 3; }
41327                 void clear() {type = 0;}
41328                 void select_id_Globalen_gNB_ID() { set(id_Globalen_gNB_ID); type=1;}
41329                 void select_id_ServedNRcellsENDCX2ManagementList() { set(id_ServedNRcellsENDCX2ManagementList); type=2;}
41330                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41331                 template<typename V>  bool decode(V& v)
41332                 {
41333                         clear();
41334                         if(!v(ref_nested())) return false;
41335                         if(equal(id_Globalen_gNB_ID)) { type = 1; return true; }
41336                         else if(equal(id_ServedNRcellsENDCX2ManagementList)) { type = 2; return true; }
41337                         else { type = 3; return true;}
41338                         return false;
41339
41340                 }
41341                 template<typename V> bool encode(V& v) const
41342                 {
41343                         return v(ref_nested());
41344
41345                 }
41346                 protected:
41347                 template<typename V>  bool decode(size_t index, V& v)
41348                 {
41349                         clear();
41350                         switch(index)
41351                         {
41352                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Globalen_gNB_ID);} return false;
41353                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedNRcellsENDCX2ManagementList);} return false;
41354                         case 3: type = 3; return v(ref_nested());
41355                         ref_nested().clear();
41356                         }
41357                         return false;
41358
41359                 }
41360                 template<typename V> bool encode(size_t index, V& v) const
41361                 {
41362                         if(index != type) {return false;} return v(ref_nested());
41363
41364                 }
41365                 private:
41366                 size_t type {0};
41367
41368         };
41369         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41370         {
41371                 size_t get_index() const {return type;}
41372                 bool is_unknown() const { return type == 3; }
41373                 void clear() {type = 0;}
41374                 void select_id_Globalen_gNB_ID() { set(reject); type=1;}
41375                 void select_id_ServedNRcellsENDCX2ManagementList() { set(reject); type=2;}
41376                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41377                 template<typename V>  bool decode(V& v)
41378                 {
41379                         clear();
41380                         if(!v(ref_nested())) return false;
41381                         if(equal(reject)) { type = 1; return true; }
41382                         else if(equal(reject)) { type = 2; return true; }
41383                         else { type = 3; return true;}
41384                         return false;
41385
41386                 }
41387                 template<typename V> bool encode(V& v) const
41388                 {
41389                         return v(ref_nested());
41390
41391                 }
41392                 protected:
41393                 template<typename V>  bool decode(size_t index, V& v)
41394                 {
41395                         clear();
41396                         switch(index)
41397                         {
41398                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41399                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
41400                         case 3: type = 3; return v(ref_nested());
41401                         ref_nested().clear();
41402                         }
41403                         return false;
41404
41405                 }
41406                 template<typename V> bool encode(size_t index, V& v) const
41407                 {
41408                         if(index != type) {return false;} return v(ref_nested());
41409
41410                 }
41411                 private:
41412                 size_t type {0};
41413
41414         };
41415         struct Value_t : asn::typefield<true>
41416         {
41417                 ~Value_t()      {clear();}
41418                 size_t get_index() const {return type;}
41419                 GlobalGNB_ID& select_id_Globalen_gNB_ID() { return set<GlobalGNB_ID>(1); }
41420                 GlobalGNB_ID const* get_id_Globalen_gNB_ID() const { return get<GlobalGNB_ID>(1); }
41421                 ServedNRcellsENDCX2ManagementList& select_id_ServedNRcellsENDCX2ManagementList() { return set<ServedNRcellsENDCX2ManagementList>(2); }
41422                 ServedNRcellsENDCX2ManagementList const* get_id_ServedNRcellsENDCX2ManagementList() const { return get<ServedNRcellsENDCX2ManagementList>(2); }
41423                 bool is_unknown() const { return type == 3; }
41424                 void clear()
41425                 {
41426                         switch(type)
41427                         {
41428                         case 1: var.destroy<GlobalGNB_ID>(); break;
41429                         case 2: var.destroy<ServedNRcellsENDCX2ManagementList>(); break;
41430                         }
41431                         type = 0; ref_nested().clear();
41432                 }
41433                 template<typename V> static inline void enumerate(V& v)
41434                 {
41435                         v.template operator()<GlobalGNB_ID>(1);
41436                         v.template operator()<ServedNRcellsENDCX2ManagementList>(2);
41437
41438                 }
41439                 protected:
41440                 template<typename V> bool decode(size_t index, V& v)
41441                 {
41442                         clear();
41443                         switch(index)
41444                         {
41445                         case 1: v(select_id_Globalen_gNB_ID()); return true;
41446                         case 2: v(select_id_ServedNRcellsENDCX2ManagementList()); return true;
41447                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
41448                         }
41449                         return false;
41450
41451                 }
41452                 template<typename V> bool encode(size_t index, V& v) const
41453                 {
41454                         if(index != type) return false;
41455                         switch(type)
41456                         {
41457                         case 1: v(var.as<GlobalGNB_ID>()); return true;
41458                         case 2: v(var.as<ServedNRcellsENDCX2ManagementList>()); return true;
41459                         }
41460                         return false;
41461
41462                 }
41463                 private:
41464                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41465                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41466                 union union_type
41467                 {
41468                         char dummy1[sizeof(GlobalGNB_ID)];
41469                         char dummy2[sizeof(ServedNRcellsENDCX2ManagementList)];
41470
41471                 };
41472                 asn::variant<sizeof(union_type)> var;
41473                 size_t type {0};
41474
41475         };
41476         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41477         {
41478                 size_t get_index() const {return type;}
41479                 bool is_unknown() const { return type == 3; }
41480                 void clear() {type = 0;}
41481                 void select_id_Globalen_gNB_ID() { set(mandatory); type=1;}
41482                 void select_id_ServedNRcellsENDCX2ManagementList() { set(mandatory); type=2;}
41483                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41484                 template<typename V>  bool decode(V& v)
41485                 {
41486                         clear();
41487                         if(!v(ref_nested())) return false;
41488                         if(equal(mandatory)) { type = 1; return true; }
41489                         else if(equal(mandatory)) { type = 2; return true; }
41490                         else { type = 3; return true;}
41491                         return false;
41492
41493                 }
41494                 template<typename V> bool encode(V& v) const
41495                 {
41496                         return v(ref_nested());
41497
41498                 }
41499                 protected:
41500                 template<typename V>  bool decode(size_t index, V& v)
41501                 {
41502                         clear();
41503                         switch(index)
41504                         {
41505                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41506                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
41507                         case 3: type = 3; return v(ref_nested());
41508                         ref_nested().clear();
41509                         }
41510                         return false;
41511
41512                 }
41513                 template<typename V> bool encode(size_t index, V& v) const
41514                 {
41515                         if(index != type) {return false;} return v(ref_nested());
41516
41517                 }
41518                 private:
41519                 size_t type {0};
41520
41521         };
41522
41523 };
41524 /*
41525 RespondingNodeType-EndcX2Setup ::= CHOICE {
41526         respond-eNB                     ProtocolIE-Container    {{ENB-ENDCX2SetupReqAckIEs}},
41527         respond-en-gNB          ProtocolIE-Container    {{En-gNB-ENDCX2SetupReqAckIEs}},
41528         ...
41529 }
41530 */
41531
41532 struct RespondingNodeType_EndcX2Setup : asn::choice<2, 0, true>
41533 {
41534         static constexpr const char* name() {return "RespondingNodeType-EndcX2Setup";}
41535         using parent_t = asn::choice<2, 0, true>;
41536         index_type get_index() const {return index;}
41537         bool is_unknown() const {return index == 3;}
41538         void set_unknown() { set_index(3);  }
41539         ~RespondingNodeType_EndcX2Setup() {clear();}
41540         struct respond_eNB_t : ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>
41541         {
41542                 static constexpr const char* name() {return "respond_eNB_t";}
41543                 using parent_t = ProtocolIE_Container<ENB_ENDCX2SetupReqAckIEs>;
41544
41545         };
41546         struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>
41547         {
41548                 static constexpr const char* name() {return "respond_en_gNB_t";}
41549                 using parent_t = ProtocolIE_Container<En_gNB_ENDCX2SetupReqAckIEs>;
41550
41551         };
41552         void clear()
41553         {
41554                 switch(get_index())
41555                 {
41556                 case 1: var.destroy<respond_eNB_t>(); break;
41557                 case 2: var.destroy<respond_en_gNB_t>(); break;
41558                 }
41559                 index = 0;
41560                 base::clear();
41561         }
41562         template<typename V> bool decode(size_t idx, V& v)
41563         {
41564                 clear();
41565                 switch(idx)
41566                 {
41567                 case 1: set_index(1); return v(var.build<respond_eNB_t>());
41568                 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
41569                 }
41570                 return false;
41571
41572         }
41573         template<typename V> bool encode(V& v) const
41574         {
41575                 switch(get_index())
41576                 {
41577                 case 1: return v(var.as<respond_eNB_t>());
41578                 case 2: return v(var.as<respond_en_gNB_t>());
41579                 }
41580                 return false;
41581         }
41582         template<typename V> static inline void enumerate(V& v)
41583         {
41584                 v.template operator()<respond_eNB_t>(1);
41585                 v.template operator()<respond_en_gNB_t>(2);
41586
41587         }
41588         respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
41589         respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
41590         respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
41591         respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
41592         private:
41593         void set_index(index_type i) {index = i; base::set();}
41594         union union_type
41595         {
41596                 char dummy1[sizeof(respond_eNB_t)];
41597                 char dummy2[sizeof(respond_en_gNB_t)];
41598
41599         };
41600         asn::variant<sizeof(union_type)>        var;
41601         index_type      index {0};
41602 };
41603 /*
41604 ENDCX2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
41605         { ID id-RespondingNodeType-EndcX2Setup          CRITICALITY reject      TYPE RespondingNodeType-EndcX2Setup             PRESENCE mandatory},
41606         ...
41607 }
41608 */
41609
41610 struct ENDCX2SetupResponse_IEs
41611 {
41612         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41613         {
41614                 size_t get_index() const {return type;}
41615                 bool is_unknown() const { return type == 2; }
41616                 void clear() {type = 0;}
41617                 void select_id_RespondingNodeType_EndcX2Setup() { set(id_RespondingNodeType_EndcX2Setup); type=1;}
41618                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41619                 template<typename V>  bool decode(V& v)
41620                 {
41621                         clear();
41622                         if(!v(ref_nested())) return false;
41623                         if(equal(id_RespondingNodeType_EndcX2Setup)) { type = 1; return true; }
41624                         else { type = 2; return true;}
41625                         return false;
41626
41627                 }
41628                 template<typename V> bool encode(V& v) const
41629                 {
41630                         return v(ref_nested());
41631
41632                 }
41633                 protected:
41634                 template<typename V>  bool decode(size_t index, V& v)
41635                 {
41636                         clear();
41637                         switch(index)
41638                         {
41639                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EndcX2Setup);} return false;
41640                         case 2: type = 2; return v(ref_nested());
41641                         ref_nested().clear();
41642                         }
41643                         return false;
41644
41645                 }
41646                 template<typename V> bool encode(size_t index, V& v) const
41647                 {
41648                         if(index != type) {return false;} return v(ref_nested());
41649
41650                 }
41651                 private:
41652                 size_t type {0};
41653
41654         };
41655         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41656         {
41657                 size_t get_index() const {return type;}
41658                 bool is_unknown() const { return type == 2; }
41659                 void clear() {type = 0;}
41660                 void select_id_RespondingNodeType_EndcX2Setup() { set(reject); type=1;}
41661                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41662                 template<typename V>  bool decode(V& v)
41663                 {
41664                         clear();
41665                         if(!v(ref_nested())) return false;
41666                         if(equal(reject)) { type = 1; return true; }
41667                         else { type = 2; return true;}
41668                         return false;
41669
41670                 }
41671                 template<typename V> bool encode(V& v) const
41672                 {
41673                         return v(ref_nested());
41674
41675                 }
41676                 protected:
41677                 template<typename V>  bool decode(size_t index, V& v)
41678                 {
41679                         clear();
41680                         switch(index)
41681                         {
41682                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41683                         case 2: type = 2; return v(ref_nested());
41684                         ref_nested().clear();
41685                         }
41686                         return false;
41687
41688                 }
41689                 template<typename V> bool encode(size_t index, V& v) const
41690                 {
41691                         if(index != type) {return false;} return v(ref_nested());
41692
41693                 }
41694                 private:
41695                 size_t type {0};
41696
41697         };
41698         struct Value_t : asn::typefield<true>
41699         {
41700                 ~Value_t()      {clear();}
41701                 size_t get_index() const {return type;}
41702                 RespondingNodeType_EndcX2Setup& select_id_RespondingNodeType_EndcX2Setup() { return set<RespondingNodeType_EndcX2Setup>(1); }
41703                 RespondingNodeType_EndcX2Setup const* get_id_RespondingNodeType_EndcX2Setup() const { return get<RespondingNodeType_EndcX2Setup>(1); }
41704                 bool is_unknown() const { return type == 2; }
41705                 void clear()
41706                 {
41707                         switch(type)
41708                         {
41709                         case 1: var.destroy<RespondingNodeType_EndcX2Setup>(); break;
41710                         }
41711                         type = 0; ref_nested().clear();
41712                 }
41713                 template<typename V> static inline void enumerate(V& v)
41714                 {
41715                         v.template operator()<RespondingNodeType_EndcX2Setup>(1);
41716
41717                 }
41718                 protected:
41719                 template<typename V> bool decode(size_t index, V& v)
41720                 {
41721                         clear();
41722                         switch(index)
41723                         {
41724                         case 1: v(select_id_RespondingNodeType_EndcX2Setup()); return true;
41725                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
41726                         }
41727                         return false;
41728
41729                 }
41730                 template<typename V> bool encode(size_t index, V& v) const
41731                 {
41732                         if(index != type) return false;
41733                         switch(type)
41734                         {
41735                         case 1: v(var.as<RespondingNodeType_EndcX2Setup>()); return true;
41736                         }
41737                         return false;
41738
41739                 }
41740                 private:
41741                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
41742                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
41743                 union union_type
41744                 {
41745                         char dummy1[sizeof(RespondingNodeType_EndcX2Setup)];
41746
41747                 };
41748                 asn::variant<sizeof(union_type)> var;
41749                 size_t type {0};
41750
41751         };
41752         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
41753         {
41754                 size_t get_index() const {return type;}
41755                 bool is_unknown() const { return type == 2; }
41756                 void clear() {type = 0;}
41757                 void select_id_RespondingNodeType_EndcX2Setup() { set(mandatory); type=1;}
41758                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
41759                 template<typename V>  bool decode(V& v)
41760                 {
41761                         clear();
41762                         if(!v(ref_nested())) return false;
41763                         if(equal(mandatory)) { type = 1; return true; }
41764                         else { type = 2; return true;}
41765                         return false;
41766
41767                 }
41768                 template<typename V> bool encode(V& v) const
41769                 {
41770                         return v(ref_nested());
41771
41772                 }
41773                 protected:
41774                 template<typename V>  bool decode(size_t index, V& v)
41775                 {
41776                         clear();
41777                         switch(index)
41778                         {
41779                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
41780                         case 2: type = 2; return v(ref_nested());
41781                         ref_nested().clear();
41782                         }
41783                         return false;
41784
41785                 }
41786                 template<typename V> bool encode(size_t index, V& v) const
41787                 {
41788                         if(index != type) {return false;} return v(ref_nested());
41789
41790                 }
41791                 private:
41792                 size_t type {0};
41793
41794         };
41795
41796 };
41797 /*
41798 ENDCX2SetupResponse ::= SEQUENCE {
41799         protocolIEs             ProtocolIE-Container    {{ENDCX2SetupResponse-IEs}},
41800         ...
41801 }
41802 */
41803
41804 struct ENDCX2SetupResponse : asn::sequence<1, 0, true, 0>
41805 {
41806         static constexpr const char* name() {return "ENDCX2SetupResponse";}
41807         using parent_t = asn::sequence<1, 0, true, 0>;
41808         struct protocolIEs_t : ProtocolIE_Container<ENDCX2SetupResponse_IEs>
41809         {
41810                 static constexpr const char* name() {return "protocolIEs_t";}
41811                 using parent_t = ProtocolIE_Container<ENDCX2SetupResponse_IEs>;
41812
41813         };
41814         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
41815         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
41816         template<typename V> void decode(V& v)
41817         {
41818                 v(protocolIEs);
41819
41820         };
41821         template<typename V> void encode(V& v) const
41822         {
41823                 v(protocolIEs);
41824
41825         };
41826         void clear()
41827         {
41828                 protocolIEs.clear();
41829
41830         };
41831         private:
41832         protocolIEs_t   protocolIEs;
41833
41834 };
41835 /*
41836 ListofEUTRACellsinNRCoordinationReq ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ECGI
41837 */
41838
41839 struct ListofEUTRACellsinNRCoordinationReq_elm : ECGI
41840 {
41841         static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq_elm";}
41842         using parent_t = ECGI;
41843
41844 };
41845 struct ListofEUTRACellsinNRCoordinationReq : asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>
41846 {
41847         static constexpr const char* name() {return "ListofEUTRACellsinNRCoordinationReq";}
41848         using parent_t = asn::sequenceof<ListofEUTRACellsinNRCoordinationReq_elm>;
41849         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
41850
41851 };
41852 /*
41853 ListofNRCellsinNRCoordinationReq ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
41854 */
41855
41856 struct ListofNRCellsinNRCoordinationReq_elm : NRCGI
41857 {
41858         static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq_elm";}
41859         using parent_t = NRCGI;
41860
41861 };
41862 struct ListofNRCellsinNRCoordinationReq : asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>
41863 {
41864         static constexpr const char* name() {return "ListofNRCellsinNRCoordinationReq";}
41865         using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationReq_elm>;
41866         using constraint_t = asn::constraints<false,asn::span<0,  maxnoNRcellsSpectrumSharingWithE_UTRA >>;
41867
41868 };
41869 /*
41870 En-gNB-EUTRA-NRCellResourceCoordinationReqIEs X2AP-PROTOCOL-IES ::= {
41871         { ID id-DataTrafficResourceIndication                   CRITICALITY reject      TYPE DataTrafficResourceIndication                              PRESENCE mandatory}|
41872         { ID id-ListofEUTRACellsinNRCoordinationReq             CRITICALITY reject      TYPE ListofEUTRACellsinNRCoordinationReq                PRESENCE mandatory }|
41873         { ID id-SpectrumSharingGroupID                                  CRITICALITY reject      TYPE SpectrumSharingGroupID                                             PRESENCE mandatory}|
41874         { ID id-ListofNRCellsinNRCoordinationReq                CRITICALITY reject      TYPE ListofNRCellsinNRCoordinationReq                   PRESENCE mandatory},
41875         ...
41876 }
41877 */
41878
41879 struct En_gNB_EUTRA_NRCellResourceCoordinationReqIEs
41880 {
41881         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
41882         {
41883                 size_t get_index() const {return type;}
41884                 bool is_unknown() const { return type == 5; }
41885                 void clear() {type = 0;}
41886                 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
41887                 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(id_ListofEUTRACellsinNRCoordinationReq); type=2;}
41888                 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=3;}
41889                 void select_id_ListofNRCellsinNRCoordinationReq() { set(id_ListofNRCellsinNRCoordinationReq); type=4;}
41890                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
41891                 template<typename V>  bool decode(V& v)
41892                 {
41893                         clear();
41894                         if(!v(ref_nested())) return false;
41895                         if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
41896                         else if(equal(id_ListofEUTRACellsinNRCoordinationReq)) { type = 2; return true; }
41897                         else if(equal(id_SpectrumSharingGroupID)) { type = 3; return true; }
41898                         else if(equal(id_ListofNRCellsinNRCoordinationReq)) { type = 4; return true; }
41899                         else { type = 5; return true;}
41900                         return false;
41901
41902                 }
41903                 template<typename V> bool encode(V& v) const
41904                 {
41905                         return v(ref_nested());
41906
41907                 }
41908                 protected:
41909                 template<typename V>  bool decode(size_t index, V& v)
41910                 {
41911                         clear();
41912                         switch(index)
41913                         {
41914                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
41915                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ListofEUTRACellsinNRCoordinationReq);} return false;
41916                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
41917                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationReq);} return false;
41918                         case 5: type = 5; return v(ref_nested());
41919                         ref_nested().clear();
41920                         }
41921                         return false;
41922
41923                 }
41924                 template<typename V> bool encode(size_t index, V& v) const
41925                 {
41926                         if(index != type) {return false;} return v(ref_nested());
41927
41928                 }
41929                 private:
41930                 size_t type {0};
41931
41932         };
41933         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
41934         {
41935                 size_t get_index() const {return type;}
41936                 bool is_unknown() const { return type == 5; }
41937                 void clear() {type = 0;}
41938                 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
41939                 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(reject); type=2;}
41940                 void select_id_SpectrumSharingGroupID() { set(reject); type=3;}
41941                 void select_id_ListofNRCellsinNRCoordinationReq() { set(reject); type=4;}
41942                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
41943                 template<typename V>  bool decode(V& v)
41944                 {
41945                         clear();
41946                         if(!v(ref_nested())) return false;
41947                         if(equal(reject)) { type = 1; return true; }
41948                         else if(equal(reject)) { type = 2; return true; }
41949                         else if(equal(reject)) { type = 3; return true; }
41950                         else if(equal(reject)) { type = 4; return true; }
41951                         else { type = 5; return true;}
41952                         return false;
41953
41954                 }
41955                 template<typename V> bool encode(V& v) const
41956                 {
41957                         return v(ref_nested());
41958
41959                 }
41960                 protected:
41961                 template<typename V>  bool decode(size_t index, V& v)
41962                 {
41963                         clear();
41964                         switch(index)
41965                         {
41966                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
41967                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
41968                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
41969                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
41970                         case 5: type = 5; return v(ref_nested());
41971                         ref_nested().clear();
41972                         }
41973                         return false;
41974
41975                 }
41976                 template<typename V> bool encode(size_t index, V& v) const
41977                 {
41978                         if(index != type) {return false;} return v(ref_nested());
41979
41980                 }
41981                 private:
41982                 size_t type {0};
41983
41984         };
41985         struct Value_t : asn::typefield<true>
41986         {
41987                 ~Value_t()      {clear();}
41988                 size_t get_index() const {return type;}
41989                 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
41990                 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
41991                 ListofEUTRACellsinNRCoordinationReq& select_id_ListofEUTRACellsinNRCoordinationReq() { return set<ListofEUTRACellsinNRCoordinationReq>(2); }
41992                 ListofEUTRACellsinNRCoordinationReq const* get_id_ListofEUTRACellsinNRCoordinationReq() const { return get<ListofEUTRACellsinNRCoordinationReq>(2); }
41993                 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(3); }
41994                 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(3); }
41995                 ListofNRCellsinNRCoordinationReq& select_id_ListofNRCellsinNRCoordinationReq() { return set<ListofNRCellsinNRCoordinationReq>(4); }
41996                 ListofNRCellsinNRCoordinationReq const* get_id_ListofNRCellsinNRCoordinationReq() const { return get<ListofNRCellsinNRCoordinationReq>(4); }
41997                 bool is_unknown() const { return type == 5; }
41998                 void clear()
41999                 {
42000                         switch(type)
42001                         {
42002                         case 1: var.destroy<DataTrafficResourceIndication>(); break;
42003                         case 2: var.destroy<ListofEUTRACellsinNRCoordinationReq>(); break;
42004                         case 3: var.destroy<SpectrumSharingGroupID>(); break;
42005                         case 4: var.destroy<ListofNRCellsinNRCoordinationReq>(); break;
42006                         }
42007                         type = 0; ref_nested().clear();
42008                 }
42009                 template<typename V> static inline void enumerate(V& v)
42010                 {
42011                         v.template operator()<DataTrafficResourceIndication>(1);
42012                         v.template operator()<ListofEUTRACellsinNRCoordinationReq>(2);
42013                         v.template operator()<SpectrumSharingGroupID>(3);
42014                         v.template operator()<ListofNRCellsinNRCoordinationReq>(4);
42015
42016                 }
42017                 protected:
42018                 template<typename V> bool decode(size_t index, V& v)
42019                 {
42020                         clear();
42021                         switch(index)
42022                         {
42023                         case 1: v(select_id_DataTrafficResourceIndication()); return true;
42024                         case 2: v(select_id_ListofEUTRACellsinNRCoordinationReq()); return true;
42025                         case 3: v(select_id_SpectrumSharingGroupID()); return true;
42026                         case 4: v(select_id_ListofNRCellsinNRCoordinationReq()); return true;
42027                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
42028                         }
42029                         return false;
42030
42031                 }
42032                 template<typename V> bool encode(size_t index, V& v) const
42033                 {
42034                         if(index != type) return false;
42035                         switch(type)
42036                         {
42037                         case 1: v(var.as<DataTrafficResourceIndication>()); return true;
42038                         case 2: v(var.as<ListofEUTRACellsinNRCoordinationReq>()); return true;
42039                         case 3: v(var.as<SpectrumSharingGroupID>()); return true;
42040                         case 4: v(var.as<ListofNRCellsinNRCoordinationReq>()); return true;
42041                         }
42042                         return false;
42043
42044                 }
42045                 private:
42046                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42047                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42048                 union union_type
42049                 {
42050                         char dummy1[sizeof(DataTrafficResourceIndication)];
42051                         char dummy2[sizeof(ListofEUTRACellsinNRCoordinationReq)];
42052                         char dummy3[sizeof(ListofNRCellsinNRCoordinationReq)];
42053                         char dummy4[sizeof(SpectrumSharingGroupID)];
42054
42055                 };
42056                 asn::variant<sizeof(union_type)> var;
42057                 size_t type {0};
42058
42059         };
42060         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42061         {
42062                 size_t get_index() const {return type;}
42063                 bool is_unknown() const { return type == 5; }
42064                 void clear() {type = 0;}
42065                 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
42066                 void select_id_ListofEUTRACellsinNRCoordinationReq() { set(mandatory); type=2;}
42067                 void select_id_SpectrumSharingGroupID() { set(mandatory); type=3;}
42068                 void select_id_ListofNRCellsinNRCoordinationReq() { set(mandatory); type=4;}
42069                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42070                 template<typename V>  bool decode(V& v)
42071                 {
42072                         clear();
42073                         if(!v(ref_nested())) return false;
42074                         if(equal(mandatory)) { type = 1; return true; }
42075                         else if(equal(mandatory)) { type = 2; return true; }
42076                         else if(equal(mandatory)) { type = 3; return true; }
42077                         else if(equal(mandatory)) { type = 4; return true; }
42078                         else { type = 5; return true;}
42079                         return false;
42080
42081                 }
42082                 template<typename V> bool encode(V& v) const
42083                 {
42084                         return v(ref_nested());
42085
42086                 }
42087                 protected:
42088                 template<typename V>  bool decode(size_t index, V& v)
42089                 {
42090                         clear();
42091                         switch(index)
42092                         {
42093                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42094                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
42095                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
42096                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
42097                         case 5: type = 5; return v(ref_nested());
42098                         ref_nested().clear();
42099                         }
42100                         return false;
42101
42102                 }
42103                 template<typename V> bool encode(size_t index, V& v) const
42104                 {
42105                         if(index != type) {return false;} return v(ref_nested());
42106
42107                 }
42108                 private:
42109                 size_t type {0};
42110
42111         };
42112
42113 };
42114 /*
42115 InitiatingNodeType-EutranrCellResourceCoordination ::= CHOICE {
42116         initiate-eNB                    ProtocolIE-Container    {{ENB-EUTRA-NRCellResourceCoordinationReqIEs}},
42117         initiate-en-gNB                 ProtocolIE-Container    {{En-gNB-EUTRA-NRCellResourceCoordinationReqIEs}},
42118         ...
42119 }
42120 */
42121
42122 struct InitiatingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
42123 {
42124         static constexpr const char* name() {return "InitiatingNodeType-EutranrCellResourceCoordination";}
42125         using parent_t = asn::choice<2, 0, true>;
42126         index_type get_index() const {return index;}
42127         bool is_unknown() const {return index == 3;}
42128         void set_unknown() { set_index(3);  }
42129         ~InitiatingNodeType_EutranrCellResourceCoordination() {clear();}
42130         struct initiate_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>
42131         {
42132                 static constexpr const char* name() {return "initiate_eNB_t";}
42133                 using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqIEs>;
42134
42135         };
42136         struct initiate_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>
42137         {
42138                 static constexpr const char* name() {return "initiate_en_gNB_t";}
42139                 using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqIEs>;
42140
42141         };
42142         void clear()
42143         {
42144                 switch(get_index())
42145                 {
42146                 case 1: var.destroy<initiate_eNB_t>(); break;
42147                 case 2: var.destroy<initiate_en_gNB_t>(); break;
42148                 }
42149                 index = 0;
42150                 base::clear();
42151         }
42152         template<typename V> bool decode(size_t idx, V& v)
42153         {
42154                 clear();
42155                 switch(idx)
42156                 {
42157                 case 1: set_index(1); return v(var.build<initiate_eNB_t>());
42158                 case 2: set_index(2); return v(var.build<initiate_en_gNB_t>());
42159                 }
42160                 return false;
42161
42162         }
42163         template<typename V> bool encode(V& v) const
42164         {
42165                 switch(get_index())
42166                 {
42167                 case 1: return v(var.as<initiate_eNB_t>());
42168                 case 2: return v(var.as<initiate_en_gNB_t>());
42169                 }
42170                 return false;
42171         }
42172         template<typename V> static inline void enumerate(V& v)
42173         {
42174                 v.template operator()<initiate_eNB_t>(1);
42175                 v.template operator()<initiate_en_gNB_t>(2);
42176
42177         }
42178         initiate_eNB_t& select_initiate_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<initiate_eNB_t>();} return var.as<initiate_eNB_t>();}
42179         initiate_eNB_t const* get_initiate_eNB() const { if(get_index() == 1) { return &var.as<initiate_eNB_t>();} return nullptr; }
42180         initiate_en_gNB_t& select_initiate_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<initiate_en_gNB_t>();} return var.as<initiate_en_gNB_t>();}
42181         initiate_en_gNB_t const* get_initiate_en_gNB() const { if(get_index() == 2) { return &var.as<initiate_en_gNB_t>();} return nullptr; }
42182         private:
42183         void set_index(index_type i) {index = i; base::set();}
42184         union union_type
42185         {
42186                 char dummy1[sizeof(initiate_eNB_t)];
42187                 char dummy2[sizeof(initiate_en_gNB_t)];
42188
42189         };
42190         asn::variant<sizeof(union_type)>        var;
42191         index_type      index {0};
42192 };
42193 /*
42194 EUTRANRCellResourceCoordinationRequest-IEs X2AP-PROTOCOL-IES ::= {
42195         { ID id-InitiatingNodeType-EutranrCellResourceCoordination              CRITICALITY reject      TYPE InitiatingNodeType-EutranrCellResourceCoordination                 PRESENCE mandatory},
42196         ...
42197 }
42198 */
42199
42200 struct EUTRANRCellResourceCoordinationRequest_IEs
42201 {
42202         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42203         {
42204                 size_t get_index() const {return type;}
42205                 bool is_unknown() const { return type == 2; }
42206                 void clear() {type = 0;}
42207                 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(id_InitiatingNodeType_EutranrCellResourceCoordination); type=1;}
42208                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42209                 template<typename V>  bool decode(V& v)
42210                 {
42211                         clear();
42212                         if(!v(ref_nested())) return false;
42213                         if(equal(id_InitiatingNodeType_EutranrCellResourceCoordination)) { type = 1; return true; }
42214                         else { type = 2; return true;}
42215                         return false;
42216
42217                 }
42218                 template<typename V> bool encode(V& v) const
42219                 {
42220                         return v(ref_nested());
42221
42222                 }
42223                 protected:
42224                 template<typename V>  bool decode(size_t index, V& v)
42225                 {
42226                         clear();
42227                         switch(index)
42228                         {
42229                         case 1: type = 1; if(v(ref_nested())) { return equal(id_InitiatingNodeType_EutranrCellResourceCoordination);} return false;
42230                         case 2: type = 2; return v(ref_nested());
42231                         ref_nested().clear();
42232                         }
42233                         return false;
42234
42235                 }
42236                 template<typename V> bool encode(size_t index, V& v) const
42237                 {
42238                         if(index != type) {return false;} return v(ref_nested());
42239
42240                 }
42241                 private:
42242                 size_t type {0};
42243
42244         };
42245         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42246         {
42247                 size_t get_index() const {return type;}
42248                 bool is_unknown() const { return type == 2; }
42249                 void clear() {type = 0;}
42250                 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(reject); type=1;}
42251                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42252                 template<typename V>  bool decode(V& v)
42253                 {
42254                         clear();
42255                         if(!v(ref_nested())) return false;
42256                         if(equal(reject)) { type = 1; return true; }
42257                         else { type = 2; return true;}
42258                         return false;
42259
42260                 }
42261                 template<typename V> bool encode(V& v) const
42262                 {
42263                         return v(ref_nested());
42264
42265                 }
42266                 protected:
42267                 template<typename V>  bool decode(size_t index, V& v)
42268                 {
42269                         clear();
42270                         switch(index)
42271                         {
42272                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42273                         case 2: type = 2; return v(ref_nested());
42274                         ref_nested().clear();
42275                         }
42276                         return false;
42277
42278                 }
42279                 template<typename V> bool encode(size_t index, V& v) const
42280                 {
42281                         if(index != type) {return false;} return v(ref_nested());
42282
42283                 }
42284                 private:
42285                 size_t type {0};
42286
42287         };
42288         struct Value_t : asn::typefield<true>
42289         {
42290                 ~Value_t()      {clear();}
42291                 size_t get_index() const {return type;}
42292                 InitiatingNodeType_EutranrCellResourceCoordination& select_id_InitiatingNodeType_EutranrCellResourceCoordination() { return set<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
42293                 InitiatingNodeType_EutranrCellResourceCoordination const* get_id_InitiatingNodeType_EutranrCellResourceCoordination() const { return get<InitiatingNodeType_EutranrCellResourceCoordination>(1); }
42294                 bool is_unknown() const { return type == 2; }
42295                 void clear()
42296                 {
42297                         switch(type)
42298                         {
42299                         case 1: var.destroy<InitiatingNodeType_EutranrCellResourceCoordination>(); break;
42300                         }
42301                         type = 0; ref_nested().clear();
42302                 }
42303                 template<typename V> static inline void enumerate(V& v)
42304                 {
42305                         v.template operator()<InitiatingNodeType_EutranrCellResourceCoordination>(1);
42306
42307                 }
42308                 protected:
42309                 template<typename V> bool decode(size_t index, V& v)
42310                 {
42311                         clear();
42312                         switch(index)
42313                         {
42314                         case 1: v(select_id_InitiatingNodeType_EutranrCellResourceCoordination()); return true;
42315                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
42316                         }
42317                         return false;
42318
42319                 }
42320                 template<typename V> bool encode(size_t index, V& v) const
42321                 {
42322                         if(index != type) return false;
42323                         switch(type)
42324                         {
42325                         case 1: v(var.as<InitiatingNodeType_EutranrCellResourceCoordination>()); return true;
42326                         }
42327                         return false;
42328
42329                 }
42330                 private:
42331                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42332                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42333                 union union_type
42334                 {
42335                         char dummy1[sizeof(InitiatingNodeType_EutranrCellResourceCoordination)];
42336
42337                 };
42338                 asn::variant<sizeof(union_type)> var;
42339                 size_t type {0};
42340
42341         };
42342         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42343         {
42344                 size_t get_index() const {return type;}
42345                 bool is_unknown() const { return type == 2; }
42346                 void clear() {type = 0;}
42347                 void select_id_InitiatingNodeType_EutranrCellResourceCoordination() { set(mandatory); type=1;}
42348                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42349                 template<typename V>  bool decode(V& v)
42350                 {
42351                         clear();
42352                         if(!v(ref_nested())) return false;
42353                         if(equal(mandatory)) { type = 1; return true; }
42354                         else { type = 2; return true;}
42355                         return false;
42356
42357                 }
42358                 template<typename V> bool encode(V& v) const
42359                 {
42360                         return v(ref_nested());
42361
42362                 }
42363                 protected:
42364                 template<typename V>  bool decode(size_t index, V& v)
42365                 {
42366                         clear();
42367                         switch(index)
42368                         {
42369                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42370                         case 2: type = 2; return v(ref_nested());
42371                         ref_nested().clear();
42372                         }
42373                         return false;
42374
42375                 }
42376                 template<typename V> bool encode(size_t index, V& v) const
42377                 {
42378                         if(index != type) {return false;} return v(ref_nested());
42379
42380                 }
42381                 private:
42382                 size_t type {0};
42383
42384         };
42385
42386 };
42387 /*
42388 EUTRANRCellResourceCoordinationRequest ::= SEQUENCE {
42389         protocolIEs             ProtocolIE-Container            {{EUTRANRCellResourceCoordinationRequest-IEs}},
42390         ...
42391 }
42392 */
42393
42394 struct EUTRANRCellResourceCoordinationRequest : asn::sequence<1, 0, true, 0>
42395 {
42396         static constexpr const char* name() {return "EUTRANRCellResourceCoordinationRequest";}
42397         using parent_t = asn::sequence<1, 0, true, 0>;
42398         struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>
42399         {
42400                 static constexpr const char* name() {return "protocolIEs_t";}
42401                 using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationRequest_IEs>;
42402
42403         };
42404         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
42405         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
42406         template<typename V> void decode(V& v)
42407         {
42408                 v(protocolIEs);
42409
42410         };
42411         template<typename V> void encode(V& v) const
42412         {
42413                 v(protocolIEs);
42414
42415         };
42416         void clear()
42417         {
42418                 protocolIEs.clear();
42419
42420         };
42421         private:
42422         protocolIEs_t   protocolIEs;
42423
42424 };
42425 /*
42426 ListofNRCellsinNRCoordinationResp ::= SEQUENCE (SIZE (0..maxnoNRcellsSpectrumSharingWithE-UTRA)) OF NRCGI
42427 */
42428
42429 struct ListofNRCellsinNRCoordinationResp_elm : NRCGI
42430 {
42431         static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp_elm";}
42432         using parent_t = NRCGI;
42433
42434 };
42435 struct ListofNRCellsinNRCoordinationResp : asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>
42436 {
42437         static constexpr const char* name() {return "ListofNRCellsinNRCoordinationResp";}
42438         using parent_t = asn::sequenceof<ListofNRCellsinNRCoordinationResp_elm>;
42439         using constraint_t = asn::constraints<false,asn::span<0,  maxnoNRcellsSpectrumSharingWithE_UTRA >>;
42440
42441 };
42442 /*
42443 En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs X2AP-PROTOCOL-IES ::= {
42444         { ID id-DataTrafficResourceIndication           CRITICALITY reject      TYPE DataTrafficResourceIndication                      PRESENCE mandatory}|
42445         { ID id-SpectrumSharingGroupID                          CRITICALITY reject      TYPE SpectrumSharingGroupID                                     PRESENCE mandatory}|
42446         { ID id-ListofNRCellsinNRCoordinationResp       CRITICALITY reject      TYPE ListofNRCellsinNRCoordinationResp          PRESENCE mandatory},
42447
42448
42449         ...
42450 }
42451 */
42452
42453 struct En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs
42454 {
42455         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42456         {
42457                 size_t get_index() const {return type;}
42458                 bool is_unknown() const { return type == 4; }
42459                 void clear() {type = 0;}
42460                 void select_id_DataTrafficResourceIndication() { set(id_DataTrafficResourceIndication); type=1;}
42461                 void select_id_SpectrumSharingGroupID() { set(id_SpectrumSharingGroupID); type=2;}
42462                 void select_id_ListofNRCellsinNRCoordinationResp() { set(id_ListofNRCellsinNRCoordinationResp); type=3;}
42463                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42464                 template<typename V>  bool decode(V& v)
42465                 {
42466                         clear();
42467                         if(!v(ref_nested())) return false;
42468                         if(equal(id_DataTrafficResourceIndication)) { type = 1; return true; }
42469                         else if(equal(id_SpectrumSharingGroupID)) { type = 2; return true; }
42470                         else if(equal(id_ListofNRCellsinNRCoordinationResp)) { type = 3; return true; }
42471                         else { type = 4; return true;}
42472                         return false;
42473
42474                 }
42475                 template<typename V> bool encode(V& v) const
42476                 {
42477                         return v(ref_nested());
42478
42479                 }
42480                 protected:
42481                 template<typename V>  bool decode(size_t index, V& v)
42482                 {
42483                         clear();
42484                         switch(index)
42485                         {
42486                         case 1: type = 1; if(v(ref_nested())) { return equal(id_DataTrafficResourceIndication);} return false;
42487                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SpectrumSharingGroupID);} return false;
42488                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ListofNRCellsinNRCoordinationResp);} return false;
42489                         case 4: type = 4; return v(ref_nested());
42490                         ref_nested().clear();
42491                         }
42492                         return false;
42493
42494                 }
42495                 template<typename V> bool encode(size_t index, V& v) const
42496                 {
42497                         if(index != type) {return false;} return v(ref_nested());
42498
42499                 }
42500                 private:
42501                 size_t type {0};
42502
42503         };
42504         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42505         {
42506                 size_t get_index() const {return type;}
42507                 bool is_unknown() const { return type == 4; }
42508                 void clear() {type = 0;}
42509                 void select_id_DataTrafficResourceIndication() { set(reject); type=1;}
42510                 void select_id_SpectrumSharingGroupID() { set(reject); type=2;}
42511                 void select_id_ListofNRCellsinNRCoordinationResp() { set(reject); type=3;}
42512                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42513                 template<typename V>  bool decode(V& v)
42514                 {
42515                         clear();
42516                         if(!v(ref_nested())) return false;
42517                         if(equal(reject)) { type = 1; return true; }
42518                         else if(equal(reject)) { type = 2; return true; }
42519                         else if(equal(reject)) { type = 3; return true; }
42520                         else { type = 4; return true;}
42521                         return false;
42522
42523                 }
42524                 template<typename V> bool encode(V& v) const
42525                 {
42526                         return v(ref_nested());
42527
42528                 }
42529                 protected:
42530                 template<typename V>  bool decode(size_t index, V& v)
42531                 {
42532                         clear();
42533                         switch(index)
42534                         {
42535                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42536                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
42537                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
42538                         case 4: type = 4; return v(ref_nested());
42539                         ref_nested().clear();
42540                         }
42541                         return false;
42542
42543                 }
42544                 template<typename V> bool encode(size_t index, V& v) const
42545                 {
42546                         if(index != type) {return false;} return v(ref_nested());
42547
42548                 }
42549                 private:
42550                 size_t type {0};
42551
42552         };
42553         struct Value_t : asn::typefield<true>
42554         {
42555                 ~Value_t()      {clear();}
42556                 size_t get_index() const {return type;}
42557                 DataTrafficResourceIndication& select_id_DataTrafficResourceIndication() { return set<DataTrafficResourceIndication>(1); }
42558                 DataTrafficResourceIndication const* get_id_DataTrafficResourceIndication() const { return get<DataTrafficResourceIndication>(1); }
42559                 SpectrumSharingGroupID& select_id_SpectrumSharingGroupID() { return set<SpectrumSharingGroupID>(2); }
42560                 SpectrumSharingGroupID const* get_id_SpectrumSharingGroupID() const { return get<SpectrumSharingGroupID>(2); }
42561                 ListofNRCellsinNRCoordinationResp& select_id_ListofNRCellsinNRCoordinationResp() { return set<ListofNRCellsinNRCoordinationResp>(3); }
42562                 ListofNRCellsinNRCoordinationResp const* get_id_ListofNRCellsinNRCoordinationResp() const { return get<ListofNRCellsinNRCoordinationResp>(3); }
42563                 bool is_unknown() const { return type == 4; }
42564                 void clear()
42565                 {
42566                         switch(type)
42567                         {
42568                         case 1: var.destroy<DataTrafficResourceIndication>(); break;
42569                         case 2: var.destroy<SpectrumSharingGroupID>(); break;
42570                         case 3: var.destroy<ListofNRCellsinNRCoordinationResp>(); break;
42571                         }
42572                         type = 0; ref_nested().clear();
42573                 }
42574                 template<typename V> static inline void enumerate(V& v)
42575                 {
42576                         v.template operator()<DataTrafficResourceIndication>(1);
42577                         v.template operator()<SpectrumSharingGroupID>(2);
42578                         v.template operator()<ListofNRCellsinNRCoordinationResp>(3);
42579
42580                 }
42581                 protected:
42582                 template<typename V> bool decode(size_t index, V& v)
42583                 {
42584                         clear();
42585                         switch(index)
42586                         {
42587                         case 1: v(select_id_DataTrafficResourceIndication()); return true;
42588                         case 2: v(select_id_SpectrumSharingGroupID()); return true;
42589                         case 3: v(select_id_ListofNRCellsinNRCoordinationResp()); return true;
42590                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
42591                         }
42592                         return false;
42593
42594                 }
42595                 template<typename V> bool encode(size_t index, V& v) const
42596                 {
42597                         if(index != type) return false;
42598                         switch(type)
42599                         {
42600                         case 1: v(var.as<DataTrafficResourceIndication>()); return true;
42601                         case 2: v(var.as<SpectrumSharingGroupID>()); return true;
42602                         case 3: v(var.as<ListofNRCellsinNRCoordinationResp>()); return true;
42603                         }
42604                         return false;
42605
42606                 }
42607                 private:
42608                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42609                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42610                 union union_type
42611                 {
42612                         char dummy1[sizeof(DataTrafficResourceIndication)];
42613                         char dummy2[sizeof(ListofNRCellsinNRCoordinationResp)];
42614                         char dummy3[sizeof(SpectrumSharingGroupID)];
42615
42616                 };
42617                 asn::variant<sizeof(union_type)> var;
42618                 size_t type {0};
42619
42620         };
42621         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42622         {
42623                 size_t get_index() const {return type;}
42624                 bool is_unknown() const { return type == 4; }
42625                 void clear() {type = 0;}
42626                 void select_id_DataTrafficResourceIndication() { set(mandatory); type=1;}
42627                 void select_id_SpectrumSharingGroupID() { set(mandatory); type=2;}
42628                 void select_id_ListofNRCellsinNRCoordinationResp() { set(mandatory); type=3;}
42629                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42630                 template<typename V>  bool decode(V& v)
42631                 {
42632                         clear();
42633                         if(!v(ref_nested())) return false;
42634                         if(equal(mandatory)) { type = 1; return true; }
42635                         else if(equal(mandatory)) { type = 2; return true; }
42636                         else if(equal(mandatory)) { type = 3; return true; }
42637                         else { type = 4; return true;}
42638                         return false;
42639
42640                 }
42641                 template<typename V> bool encode(V& v) const
42642                 {
42643                         return v(ref_nested());
42644
42645                 }
42646                 protected:
42647                 template<typename V>  bool decode(size_t index, V& v)
42648                 {
42649                         clear();
42650                         switch(index)
42651                         {
42652                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42653                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
42654                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
42655                         case 4: type = 4; return v(ref_nested());
42656                         ref_nested().clear();
42657                         }
42658                         return false;
42659
42660                 }
42661                 template<typename V> bool encode(size_t index, V& v) const
42662                 {
42663                         if(index != type) {return false;} return v(ref_nested());
42664
42665                 }
42666                 private:
42667                 size_t type {0};
42668
42669         };
42670
42671 };
42672 /*
42673 RespondingNodeType-EutranrCellResourceCoordination ::= CHOICE {
42674         respond-eNB                     ProtocolIE-Container    {{ENB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
42675         respond-en-gNB          ProtocolIE-Container    {{En-gNB-EUTRA-NRCellResourceCoordinationReqAckIEs}},
42676         ...
42677 }
42678 */
42679
42680 struct RespondingNodeType_EutranrCellResourceCoordination : asn::choice<2, 0, true>
42681 {
42682         static constexpr const char* name() {return "RespondingNodeType-EutranrCellResourceCoordination";}
42683         using parent_t = asn::choice<2, 0, true>;
42684         index_type get_index() const {return index;}
42685         bool is_unknown() const {return index == 3;}
42686         void set_unknown() { set_index(3);  }
42687         ~RespondingNodeType_EutranrCellResourceCoordination() {clear();}
42688         struct respond_eNB_t : ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>
42689         {
42690                 static constexpr const char* name() {return "respond_eNB_t";}
42691                 using parent_t = ProtocolIE_Container<ENB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
42692
42693         };
42694         struct respond_en_gNB_t : ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>
42695         {
42696                 static constexpr const char* name() {return "respond_en_gNB_t";}
42697                 using parent_t = ProtocolIE_Container<En_gNB_EUTRA_NRCellResourceCoordinationReqAckIEs>;
42698
42699         };
42700         void clear()
42701         {
42702                 switch(get_index())
42703                 {
42704                 case 1: var.destroy<respond_eNB_t>(); break;
42705                 case 2: var.destroy<respond_en_gNB_t>(); break;
42706                 }
42707                 index = 0;
42708                 base::clear();
42709         }
42710         template<typename V> bool decode(size_t idx, V& v)
42711         {
42712                 clear();
42713                 switch(idx)
42714                 {
42715                 case 1: set_index(1); return v(var.build<respond_eNB_t>());
42716                 case 2: set_index(2); return v(var.build<respond_en_gNB_t>());
42717                 }
42718                 return false;
42719
42720         }
42721         template<typename V> bool encode(V& v) const
42722         {
42723                 switch(get_index())
42724                 {
42725                 case 1: return v(var.as<respond_eNB_t>());
42726                 case 2: return v(var.as<respond_en_gNB_t>());
42727                 }
42728                 return false;
42729         }
42730         template<typename V> static inline void enumerate(V& v)
42731         {
42732                 v.template operator()<respond_eNB_t>(1);
42733                 v.template operator()<respond_en_gNB_t>(2);
42734
42735         }
42736         respond_eNB_t& select_respond_eNB() { if(get_index() != 1) { clear(); set_index(1); return var.build<respond_eNB_t>();} return var.as<respond_eNB_t>();}
42737         respond_eNB_t const* get_respond_eNB() const { if(get_index() == 1) { return &var.as<respond_eNB_t>();} return nullptr; }
42738         respond_en_gNB_t& select_respond_en_gNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<respond_en_gNB_t>();} return var.as<respond_en_gNB_t>();}
42739         respond_en_gNB_t const* get_respond_en_gNB() const { if(get_index() == 2) { return &var.as<respond_en_gNB_t>();} return nullptr; }
42740         private:
42741         void set_index(index_type i) {index = i; base::set();}
42742         union union_type
42743         {
42744                 char dummy1[sizeof(respond_eNB_t)];
42745                 char dummy2[sizeof(respond_en_gNB_t)];
42746
42747         };
42748         asn::variant<sizeof(union_type)>        var;
42749         index_type      index {0};
42750 };
42751 /*
42752 EUTRANRCellResourceCoordinationResponse-IEs X2AP-PROTOCOL-IES ::= {
42753         { ID id-RespondingNodeType-EutranrCellResourceCoordination              CRITICALITY reject      TYPE RespondingNodeType-EutranrCellResourceCoordination                 PRESENCE mandatory},
42754         ...
42755 }
42756 */
42757
42758 struct EUTRANRCellResourceCoordinationResponse_IEs
42759 {
42760         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42761         {
42762                 size_t get_index() const {return type;}
42763                 bool is_unknown() const { return type == 2; }
42764                 void clear() {type = 0;}
42765                 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(id_RespondingNodeType_EutranrCellResourceCoordination); type=1;}
42766                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
42767                 template<typename V>  bool decode(V& v)
42768                 {
42769                         clear();
42770                         if(!v(ref_nested())) return false;
42771                         if(equal(id_RespondingNodeType_EutranrCellResourceCoordination)) { type = 1; return true; }
42772                         else { type = 2; return true;}
42773                         return false;
42774
42775                 }
42776                 template<typename V> bool encode(V& v) const
42777                 {
42778                         return v(ref_nested());
42779
42780                 }
42781                 protected:
42782                 template<typename V>  bool decode(size_t index, V& v)
42783                 {
42784                         clear();
42785                         switch(index)
42786                         {
42787                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RespondingNodeType_EutranrCellResourceCoordination);} return false;
42788                         case 2: type = 2; return v(ref_nested());
42789                         ref_nested().clear();
42790                         }
42791                         return false;
42792
42793                 }
42794                 template<typename V> bool encode(size_t index, V& v) const
42795                 {
42796                         if(index != type) {return false;} return v(ref_nested());
42797
42798                 }
42799                 private:
42800                 size_t type {0};
42801
42802         };
42803         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
42804         {
42805                 size_t get_index() const {return type;}
42806                 bool is_unknown() const { return type == 2; }
42807                 void clear() {type = 0;}
42808                 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(reject); type=1;}
42809                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
42810                 template<typename V>  bool decode(V& v)
42811                 {
42812                         clear();
42813                         if(!v(ref_nested())) return false;
42814                         if(equal(reject)) { type = 1; return true; }
42815                         else { type = 2; return true;}
42816                         return false;
42817
42818                 }
42819                 template<typename V> bool encode(V& v) const
42820                 {
42821                         return v(ref_nested());
42822
42823                 }
42824                 protected:
42825                 template<typename V>  bool decode(size_t index, V& v)
42826                 {
42827                         clear();
42828                         switch(index)
42829                         {
42830                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
42831                         case 2: type = 2; return v(ref_nested());
42832                         ref_nested().clear();
42833                         }
42834                         return false;
42835
42836                 }
42837                 template<typename V> bool encode(size_t index, V& v) const
42838                 {
42839                         if(index != type) {return false;} return v(ref_nested());
42840
42841                 }
42842                 private:
42843                 size_t type {0};
42844
42845         };
42846         struct Value_t : asn::typefield<true>
42847         {
42848                 ~Value_t()      {clear();}
42849                 size_t get_index() const {return type;}
42850                 RespondingNodeType_EutranrCellResourceCoordination& select_id_RespondingNodeType_EutranrCellResourceCoordination() { return set<RespondingNodeType_EutranrCellResourceCoordination>(1); }
42851                 RespondingNodeType_EutranrCellResourceCoordination const* get_id_RespondingNodeType_EutranrCellResourceCoordination() const { return get<RespondingNodeType_EutranrCellResourceCoordination>(1); }
42852                 bool is_unknown() const { return type == 2; }
42853                 void clear()
42854                 {
42855                         switch(type)
42856                         {
42857                         case 1: var.destroy<RespondingNodeType_EutranrCellResourceCoordination>(); break;
42858                         }
42859                         type = 0; ref_nested().clear();
42860                 }
42861                 template<typename V> static inline void enumerate(V& v)
42862                 {
42863                         v.template operator()<RespondingNodeType_EutranrCellResourceCoordination>(1);
42864
42865                 }
42866                 protected:
42867                 template<typename V> bool decode(size_t index, V& v)
42868                 {
42869                         clear();
42870                         switch(index)
42871                         {
42872                         case 1: v(select_id_RespondingNodeType_EutranrCellResourceCoordination()); return true;
42873                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
42874                         }
42875                         return false;
42876
42877                 }
42878                 template<typename V> bool encode(size_t index, V& v) const
42879                 {
42880                         if(index != type) return false;
42881                         switch(type)
42882                         {
42883                         case 1: v(var.as<RespondingNodeType_EutranrCellResourceCoordination>()); return true;
42884                         }
42885                         return false;
42886
42887                 }
42888                 private:
42889                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
42890                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
42891                 union union_type
42892                 {
42893                         char dummy1[sizeof(RespondingNodeType_EutranrCellResourceCoordination)];
42894
42895                 };
42896                 asn::variant<sizeof(union_type)> var;
42897                 size_t type {0};
42898
42899         };
42900         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
42901         {
42902                 size_t get_index() const {return type;}
42903                 bool is_unknown() const { return type == 2; }
42904                 void clear() {type = 0;}
42905                 void select_id_RespondingNodeType_EutranrCellResourceCoordination() { set(mandatory); type=1;}
42906                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
42907                 template<typename V>  bool decode(V& v)
42908                 {
42909                         clear();
42910                         if(!v(ref_nested())) return false;
42911                         if(equal(mandatory)) { type = 1; return true; }
42912                         else { type = 2; return true;}
42913                         return false;
42914
42915                 }
42916                 template<typename V> bool encode(V& v) const
42917                 {
42918                         return v(ref_nested());
42919
42920                 }
42921                 protected:
42922                 template<typename V>  bool decode(size_t index, V& v)
42923                 {
42924                         clear();
42925                         switch(index)
42926                         {
42927                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
42928                         case 2: type = 2; return v(ref_nested());
42929                         ref_nested().clear();
42930                         }
42931                         return false;
42932
42933                 }
42934                 template<typename V> bool encode(size_t index, V& v) const
42935                 {
42936                         if(index != type) {return false;} return v(ref_nested());
42937
42938                 }
42939                 private:
42940                 size_t type {0};
42941
42942         };
42943
42944 };
42945 /*
42946 EUTRANRCellResourceCoordinationResponse ::= SEQUENCE {
42947         protocolIEs             ProtocolIE-Container            {{EUTRANRCellResourceCoordinationResponse-IEs}},
42948         ...
42949 }
42950 */
42951
42952 struct EUTRANRCellResourceCoordinationResponse : asn::sequence<1, 0, true, 0>
42953 {
42954         static constexpr const char* name() {return "EUTRANRCellResourceCoordinationResponse";}
42955         using parent_t = asn::sequence<1, 0, true, 0>;
42956         struct protocolIEs_t : ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>
42957         {
42958                 static constexpr const char* name() {return "protocolIEs_t";}
42959                 using parent_t = ProtocolIE_Container<EUTRANRCellResourceCoordinationResponse_IEs>;
42960
42961         };
42962         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
42963         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
42964         template<typename V> void decode(V& v)
42965         {
42966                 v(protocolIEs);
42967
42968         };
42969         template<typename V> void encode(V& v) const
42970         {
42971                 v(protocolIEs);
42972
42973         };
42974         void clear()
42975         {
42976                 protocolIEs.clear();
42977
42978         };
42979         private:
42980         protocolIEs_t   protocolIEs;
42981
42982 };
42983 /*
42984 ErrorIndication-IEs X2AP-PROTOCOL-IES ::= {
42985         { ID id-Old-eNB-UE-X2AP-ID                                      CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE optional}|
42986         { ID id-New-eNB-UE-X2AP-ID                                      CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE optional}|
42987         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE optional}|
42988         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
42989         { ID id-Old-eNB-UE-X2AP-ID-Extension            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
42990         { ID id-New-eNB-UE-X2AP-ID-Extension            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
42991         { ID id-Old-SgNB-UE-X2AP-ID                                     CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                    PRESENCE optional},
42992         ...
42993 }
42994 */
42995
42996 struct ErrorIndication_IEs
42997 {
42998         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
42999         {
43000                 size_t get_index() const {return type;}
43001                 bool is_unknown() const { return type == 8; }
43002                 void clear() {type = 0;}
43003                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43004                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
43005                 void select_id_Cause() { set(id_Cause); type=3;}
43006                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
43007                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=5;}
43008                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=6;}
43009                 void select_id_Old_SgNB_UE_X2AP_ID() { set(id_Old_SgNB_UE_X2AP_ID); type=7;}
43010                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43011                 template<typename V>  bool decode(V& v)
43012                 {
43013                         clear();
43014                         if(!v(ref_nested())) return false;
43015                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43016                         else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
43017                         else if(equal(id_Cause)) { type = 3; return true; }
43018                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
43019                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
43020                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
43021                         else if(equal(id_Old_SgNB_UE_X2AP_ID)) { type = 7; return true; }
43022                         else { type = 8; return true;}
43023                         return false;
43024
43025                 }
43026                 template<typename V> bool encode(V& v) const
43027                 {
43028                         return v(ref_nested());
43029
43030                 }
43031                 protected:
43032                 template<typename V>  bool decode(size_t index, V& v)
43033                 {
43034                         clear();
43035                         switch(index)
43036                         {
43037                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43038                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
43039                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
43040                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
43041                         case 5: type = 5; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43042                         case 6: type = 6; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
43043                         case 7: type = 7; if(v(ref_nested())) { return equal(id_Old_SgNB_UE_X2AP_ID);} return false;
43044                         case 8: type = 8; return v(ref_nested());
43045                         ref_nested().clear();
43046                         }
43047                         return false;
43048
43049                 }
43050                 template<typename V> bool encode(size_t index, V& v) const
43051                 {
43052                         if(index != type) {return false;} return v(ref_nested());
43053
43054                 }
43055                 private:
43056                 size_t type {0};
43057
43058         };
43059         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43060         {
43061                 size_t get_index() const {return type;}
43062                 bool is_unknown() const { return type == 8; }
43063                 void clear() {type = 0;}
43064                 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
43065                 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
43066                 void select_id_Cause() { set(ignore); type=3;}
43067                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
43068                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
43069                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
43070                 void select_id_Old_SgNB_UE_X2AP_ID() { set(ignore); type=7;}
43071                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43072                 template<typename V>  bool decode(V& v)
43073                 {
43074                         clear();
43075                         if(!v(ref_nested())) return false;
43076                         if(equal(ignore)) { type = 1; return true; }
43077                         else if(equal(ignore)) { type = 2; return true; }
43078                         else if(equal(ignore)) { type = 3; return true; }
43079                         else if(equal(ignore)) { type = 4; return true; }
43080                         else if(equal(ignore)) { type = 5; return true; }
43081                         else if(equal(ignore)) { type = 6; return true; }
43082                         else if(equal(ignore)) { type = 7; return true; }
43083                         else { type = 8; return true;}
43084                         return false;
43085
43086                 }
43087                 template<typename V> bool encode(V& v) const
43088                 {
43089                         return v(ref_nested());
43090
43091                 }
43092                 protected:
43093                 template<typename V>  bool decode(size_t index, V& v)
43094                 {
43095                         clear();
43096                         switch(index)
43097                         {
43098                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43099                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43100                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43101                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
43102                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
43103                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
43104                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
43105                         case 8: type = 8; return v(ref_nested());
43106                         ref_nested().clear();
43107                         }
43108                         return false;
43109
43110                 }
43111                 template<typename V> bool encode(size_t index, V& v) const
43112                 {
43113                         if(index != type) {return false;} return v(ref_nested());
43114
43115                 }
43116                 private:
43117                 size_t type {0};
43118
43119         };
43120         struct Value_t : asn::typefield<true>
43121         {
43122                 ~Value_t()      {clear();}
43123                 size_t get_index() const {return type;}
43124                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43125                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43126                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
43127                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
43128                 Cause& select_id_Cause() { return set<Cause>(3); }
43129                 Cause const* get_id_Cause() const { return get<Cause>(3); }
43130                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
43131                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
43132                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
43133                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
43134                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
43135                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
43136                 SgNB_UE_X2AP_ID& select_id_Old_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(7); }
43137                 SgNB_UE_X2AP_ID const* get_id_Old_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(7); }
43138                 bool is_unknown() const { return type == 8; }
43139                 void clear()
43140                 {
43141                         switch(type)
43142                         {
43143                         case 1: var.destroy<UE_X2AP_ID>(); break;
43144                         case 2: var.destroy<UE_X2AP_ID>(); break;
43145                         case 3: var.destroy<Cause>(); break;
43146                         case 4: var.destroy<CriticalityDiagnostics>(); break;
43147                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
43148                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
43149                         case 7: var.destroy<SgNB_UE_X2AP_ID>(); break;
43150                         }
43151                         type = 0; ref_nested().clear();
43152                 }
43153                 template<typename V> static inline void enumerate(V& v)
43154                 {
43155                         v.template operator()<UE_X2AP_ID>(1);
43156                         v.template operator()<UE_X2AP_ID>(2);
43157                         v.template operator()<Cause>(3);
43158                         v.template operator()<CriticalityDiagnostics>(4);
43159                         v.template operator()<UE_X2AP_ID_Extension>(5);
43160                         v.template operator()<UE_X2AP_ID_Extension>(6);
43161                         v.template operator()<SgNB_UE_X2AP_ID>(7);
43162
43163                 }
43164                 protected:
43165                 template<typename V> bool decode(size_t index, V& v)
43166                 {
43167                         clear();
43168                         switch(index)
43169                         {
43170                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
43171                         case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
43172                         case 3: v(select_id_Cause()); return true;
43173                         case 4: v(select_id_CriticalityDiagnostics()); return true;
43174                         case 5: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
43175                         case 6: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
43176                         case 7: v(select_id_Old_SgNB_UE_X2AP_ID()); return true;
43177                         case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
43178                         }
43179                         return false;
43180
43181                 }
43182                 template<typename V> bool encode(size_t index, V& v) const
43183                 {
43184                         if(index != type) return false;
43185                         switch(type)
43186                         {
43187                         case 1: v(var.as<UE_X2AP_ID>()); return true;
43188                         case 2: v(var.as<UE_X2AP_ID>()); return true;
43189                         case 3: v(var.as<Cause>()); return true;
43190                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
43191                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
43192                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
43193                         case 7: v(var.as<SgNB_UE_X2AP_ID>()); return true;
43194                         }
43195                         return false;
43196
43197                 }
43198                 private:
43199                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43200                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43201                 union union_type
43202                 {
43203                         char dummy1[sizeof(Cause)];
43204                         char dummy2[sizeof(CriticalityDiagnostics)];
43205                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
43206                         char dummy4[sizeof(UE_X2AP_ID)];
43207                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
43208
43209                 };
43210                 asn::variant<sizeof(union_type)> var;
43211                 size_t type {0};
43212
43213         };
43214         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43215         {
43216                 size_t get_index() const {return type;}
43217                 bool is_unknown() const { return type == 8; }
43218                 void clear() {type = 0;}
43219                 void select_id_Old_eNB_UE_X2AP_ID() { set(optional); type=1;}
43220                 void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
43221                 void select_id_Cause() { set(optional); type=3;}
43222                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
43223                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
43224                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
43225                 void select_id_Old_SgNB_UE_X2AP_ID() { set(optional); type=7;}
43226                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43227                 template<typename V>  bool decode(V& v)
43228                 {
43229                         clear();
43230                         if(!v(ref_nested())) return false;
43231                         if(equal(optional)) { type = 1; return true; }
43232                         else if(equal(optional)) { type = 2; return true; }
43233                         else if(equal(optional)) { type = 3; return true; }
43234                         else if(equal(optional)) { type = 4; return true; }
43235                         else if(equal(optional)) { type = 5; return true; }
43236                         else if(equal(optional)) { type = 6; return true; }
43237                         else if(equal(optional)) { type = 7; return true; }
43238                         else { type = 8; return true;}
43239                         return false;
43240
43241                 }
43242                 template<typename V> bool encode(V& v) const
43243                 {
43244                         return v(ref_nested());
43245
43246                 }
43247                 protected:
43248                 template<typename V>  bool decode(size_t index, V& v)
43249                 {
43250                         clear();
43251                         switch(index)
43252                         {
43253                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
43254                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
43255                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
43256                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
43257                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
43258                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
43259                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
43260                         case 8: type = 8; return v(ref_nested());
43261                         ref_nested().clear();
43262                         }
43263                         return false;
43264
43265                 }
43266                 template<typename V> bool encode(size_t index, V& v) const
43267                 {
43268                         if(index != type) {return false;} return v(ref_nested());
43269
43270                 }
43271                 private:
43272                 size_t type {0};
43273
43274         };
43275
43276 };
43277 /*
43278 ErrorIndication ::= SEQUENCE {
43279         protocolIEs             ProtocolIE-Container    {{ErrorIndication-IEs}},
43280         ...
43281 }
43282 */
43283
43284 struct ErrorIndication : asn::sequence<1, 0, true, 0>
43285 {
43286         static constexpr const char* name() {return "ErrorIndication";}
43287         using parent_t = asn::sequence<1, 0, true, 0>;
43288         struct protocolIEs_t : ProtocolIE_Container<ErrorIndication_IEs>
43289         {
43290                 static constexpr const char* name() {return "protocolIEs_t";}
43291                 using parent_t = ProtocolIE_Container<ErrorIndication_IEs>;
43292
43293         };
43294         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43295         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43296         template<typename V> void decode(V& v)
43297         {
43298                 v(protocolIEs);
43299
43300         };
43301         template<typename V> void encode(V& v) const
43302         {
43303                 v(protocolIEs);
43304
43305         };
43306         void clear()
43307         {
43308                 protocolIEs.clear();
43309
43310         };
43311         private:
43312         protocolIEs_t   protocolIEs;
43313
43314 };
43315 /*
43316 GNBStatusIndicationIEs X2AP-PROTOCOL-IES ::= {
43317         { ID id-GNBOverloadInformation          CRITICALITY ignore      TYPE GNBOverloadInformation             PRESENCE mandatory},
43318         ...
43319 }
43320 */
43321
43322 struct GNBStatusIndicationIEs
43323 {
43324         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43325         {
43326                 size_t get_index() const {return type;}
43327                 bool is_unknown() const { return type == 2; }
43328                 void clear() {type = 0;}
43329                 void select_id_GNBOverloadInformation() { set(id_GNBOverloadInformation); type=1;}
43330                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43331                 template<typename V>  bool decode(V& v)
43332                 {
43333                         clear();
43334                         if(!v(ref_nested())) return false;
43335                         if(equal(id_GNBOverloadInformation)) { type = 1; return true; }
43336                         else { type = 2; return true;}
43337                         return false;
43338
43339                 }
43340                 template<typename V> bool encode(V& v) const
43341                 {
43342                         return v(ref_nested());
43343
43344                 }
43345                 protected:
43346                 template<typename V>  bool decode(size_t index, V& v)
43347                 {
43348                         clear();
43349                         switch(index)
43350                         {
43351                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GNBOverloadInformation);} return false;
43352                         case 2: type = 2; return v(ref_nested());
43353                         ref_nested().clear();
43354                         }
43355                         return false;
43356
43357                 }
43358                 template<typename V> bool encode(size_t index, V& v) const
43359                 {
43360                         if(index != type) {return false;} return v(ref_nested());
43361
43362                 }
43363                 private:
43364                 size_t type {0};
43365
43366         };
43367         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43368         {
43369                 size_t get_index() const {return type;}
43370                 bool is_unknown() const { return type == 2; }
43371                 void clear() {type = 0;}
43372                 void select_id_GNBOverloadInformation() { set(ignore); type=1;}
43373                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43374                 template<typename V>  bool decode(V& v)
43375                 {
43376                         clear();
43377                         if(!v(ref_nested())) return false;
43378                         if(equal(ignore)) { type = 1; return true; }
43379                         else { type = 2; return true;}
43380                         return false;
43381
43382                 }
43383                 template<typename V> bool encode(V& v) const
43384                 {
43385                         return v(ref_nested());
43386
43387                 }
43388                 protected:
43389                 template<typename V>  bool decode(size_t index, V& v)
43390                 {
43391                         clear();
43392                         switch(index)
43393                         {
43394                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43395                         case 2: type = 2; return v(ref_nested());
43396                         ref_nested().clear();
43397                         }
43398                         return false;
43399
43400                 }
43401                 template<typename V> bool encode(size_t index, V& v) const
43402                 {
43403                         if(index != type) {return false;} return v(ref_nested());
43404
43405                 }
43406                 private:
43407                 size_t type {0};
43408
43409         };
43410         struct Value_t : asn::typefield<true>
43411         {
43412                 ~Value_t()      {clear();}
43413                 size_t get_index() const {return type;}
43414                 GNBOverloadInformation& select_id_GNBOverloadInformation() { return set<GNBOverloadInformation>(1); }
43415                 GNBOverloadInformation const* get_id_GNBOverloadInformation() const { return get<GNBOverloadInformation>(1); }
43416                 bool is_unknown() const { return type == 2; }
43417                 void clear()
43418                 {
43419                         switch(type)
43420                         {
43421                         case 1: var.destroy<GNBOverloadInformation>(); break;
43422                         }
43423                         type = 0; ref_nested().clear();
43424                 }
43425                 template<typename V> static inline void enumerate(V& v)
43426                 {
43427                         v.template operator()<GNBOverloadInformation>(1);
43428
43429                 }
43430                 protected:
43431                 template<typename V> bool decode(size_t index, V& v)
43432                 {
43433                         clear();
43434                         switch(index)
43435                         {
43436                         case 1: v(select_id_GNBOverloadInformation()); return true;
43437                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
43438                         }
43439                         return false;
43440
43441                 }
43442                 template<typename V> bool encode(size_t index, V& v) const
43443                 {
43444                         if(index != type) return false;
43445                         switch(type)
43446                         {
43447                         case 1: v(var.as<GNBOverloadInformation>()); return true;
43448                         }
43449                         return false;
43450
43451                 }
43452                 private:
43453                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43454                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43455                 union union_type
43456                 {
43457                         char dummy1[sizeof(GNBOverloadInformation)];
43458
43459                 };
43460                 asn::variant<sizeof(union_type)> var;
43461                 size_t type {0};
43462
43463         };
43464         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43465         {
43466                 size_t get_index() const {return type;}
43467                 bool is_unknown() const { return type == 2; }
43468                 void clear() {type = 0;}
43469                 void select_id_GNBOverloadInformation() { set(mandatory); type=1;}
43470                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43471                 template<typename V>  bool decode(V& v)
43472                 {
43473                         clear();
43474                         if(!v(ref_nested())) return false;
43475                         if(equal(mandatory)) { type = 1; return true; }
43476                         else { type = 2; return true;}
43477                         return false;
43478
43479                 }
43480                 template<typename V> bool encode(V& v) const
43481                 {
43482                         return v(ref_nested());
43483
43484                 }
43485                 protected:
43486                 template<typename V>  bool decode(size_t index, V& v)
43487                 {
43488                         clear();
43489                         switch(index)
43490                         {
43491                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
43492                         case 2: type = 2; return v(ref_nested());
43493                         ref_nested().clear();
43494                         }
43495                         return false;
43496
43497                 }
43498                 template<typename V> bool encode(size_t index, V& v) const
43499                 {
43500                         if(index != type) {return false;} return v(ref_nested());
43501
43502                 }
43503                 private:
43504                 size_t type {0};
43505
43506         };
43507
43508 };
43509 /*
43510 GNBStatusIndication ::= SEQUENCE {
43511         protocolIEs                     ProtocolIE-Container    { { GNBStatusIndicationIEs} },
43512         ...
43513 }
43514 */
43515
43516 struct GNBStatusIndication : asn::sequence<1, 0, true, 0>
43517 {
43518         static constexpr const char* name() {return "GNBStatusIndication";}
43519         using parent_t = asn::sequence<1, 0, true, 0>;
43520         struct protocolIEs_t : ProtocolIE_Container<GNBStatusIndicationIEs>
43521         {
43522                 static constexpr const char* name() {return "protocolIEs_t";}
43523                 using parent_t = ProtocolIE_Container<GNBStatusIndicationIEs>;
43524
43525         };
43526         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43527         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43528         template<typename V> void decode(V& v)
43529         {
43530                 v(protocolIEs);
43531
43532         };
43533         template<typename V> void encode(V& v) const
43534         {
43535                 v(protocolIEs);
43536
43537         };
43538         void clear()
43539         {
43540                 protocolIEs.clear();
43541
43542         };
43543         private:
43544         protocolIEs_t   protocolIEs;
43545
43546 };
43547 /*
43548 HandoverCancel-IEs X2AP-PROTOCOL-IES ::= {
43549         { ID id-Old-eNB-UE-X2AP-ID                                      CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
43550         { ID id-New-eNB-UE-X2AP-ID                                      CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE optional}|
43551         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
43552         { ID id-Old-eNB-UE-X2AP-ID-Extension            CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
43553         { ID id-New-eNB-UE-X2AP-ID-Extension            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
43554         ...
43555 }
43556 */
43557
43558 struct HandoverCancel_IEs
43559 {
43560         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43561         {
43562                 size_t get_index() const {return type;}
43563                 bool is_unknown() const { return type == 6; }
43564                 void clear() {type = 0;}
43565                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43566                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
43567                 void select_id_Cause() { set(id_Cause); type=3;}
43568                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
43569                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
43570                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43571                 template<typename V>  bool decode(V& v)
43572                 {
43573                         clear();
43574                         if(!v(ref_nested())) return false;
43575                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43576                         else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
43577                         else if(equal(id_Cause)) { type = 3; return true; }
43578                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
43579                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
43580                         else { type = 6; return true;}
43581                         return false;
43582
43583                 }
43584                 template<typename V> bool encode(V& v) const
43585                 {
43586                         return v(ref_nested());
43587
43588                 }
43589                 protected:
43590                 template<typename V>  bool decode(size_t index, V& v)
43591                 {
43592                         clear();
43593                         switch(index)
43594                         {
43595                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43596                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
43597                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
43598                         case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43599                         case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
43600                         case 6: type = 6; return v(ref_nested());
43601                         ref_nested().clear();
43602                         }
43603                         return false;
43604
43605                 }
43606                 template<typename V> bool encode(size_t index, V& v) const
43607                 {
43608                         if(index != type) {return false;} return v(ref_nested());
43609
43610                 }
43611                 private:
43612                 size_t type {0};
43613
43614         };
43615         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43616         {
43617                 size_t get_index() const {return type;}
43618                 bool is_unknown() const { return type == 6; }
43619                 void clear() {type = 0;}
43620                 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
43621                 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
43622                 void select_id_Cause() { set(ignore); type=3;}
43623                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
43624                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
43625                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43626                 template<typename V>  bool decode(V& v)
43627                 {
43628                         clear();
43629                         if(!v(ref_nested())) return false;
43630                         if(equal(reject)) { type = 1; return true; }
43631                         else if(equal(ignore)) { type = 2; return true; }
43632                         else if(equal(ignore)) { type = 3; return true; }
43633                         else if(equal(reject)) { type = 4; return true; }
43634                         else if(equal(ignore)) { type = 5; return true; }
43635                         else { type = 6; return true;}
43636                         return false;
43637
43638                 }
43639                 template<typename V> bool encode(V& v) const
43640                 {
43641                         return v(ref_nested());
43642
43643                 }
43644                 protected:
43645                 template<typename V>  bool decode(size_t index, V& v)
43646                 {
43647                         clear();
43648                         switch(index)
43649                         {
43650                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
43651                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43652                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43653                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
43654                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
43655                         case 6: type = 6; return v(ref_nested());
43656                         ref_nested().clear();
43657                         }
43658                         return false;
43659
43660                 }
43661                 template<typename V> bool encode(size_t index, V& v) const
43662                 {
43663                         if(index != type) {return false;} return v(ref_nested());
43664
43665                 }
43666                 private:
43667                 size_t type {0};
43668
43669         };
43670         struct Value_t : asn::typefield<true>
43671         {
43672                 ~Value_t()      {clear();}
43673                 size_t get_index() const {return type;}
43674                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43675                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43676                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
43677                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
43678                 Cause& select_id_Cause() { return set<Cause>(3); }
43679                 Cause const* get_id_Cause() const { return get<Cause>(3); }
43680                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
43681                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
43682                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
43683                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
43684                 bool is_unknown() const { return type == 6; }
43685                 void clear()
43686                 {
43687                         switch(type)
43688                         {
43689                         case 1: var.destroy<UE_X2AP_ID>(); break;
43690                         case 2: var.destroy<UE_X2AP_ID>(); break;
43691                         case 3: var.destroy<Cause>(); break;
43692                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
43693                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
43694                         }
43695                         type = 0; ref_nested().clear();
43696                 }
43697                 template<typename V> static inline void enumerate(V& v)
43698                 {
43699                         v.template operator()<UE_X2AP_ID>(1);
43700                         v.template operator()<UE_X2AP_ID>(2);
43701                         v.template operator()<Cause>(3);
43702                         v.template operator()<UE_X2AP_ID_Extension>(4);
43703                         v.template operator()<UE_X2AP_ID_Extension>(5);
43704
43705                 }
43706                 protected:
43707                 template<typename V> bool decode(size_t index, V& v)
43708                 {
43709                         clear();
43710                         switch(index)
43711                         {
43712                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
43713                         case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
43714                         case 3: v(select_id_Cause()); return true;
43715                         case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
43716                         case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
43717                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
43718                         }
43719                         return false;
43720
43721                 }
43722                 template<typename V> bool encode(size_t index, V& v) const
43723                 {
43724                         if(index != type) return false;
43725                         switch(type)
43726                         {
43727                         case 1: v(var.as<UE_X2AP_ID>()); return true;
43728                         case 2: v(var.as<UE_X2AP_ID>()); return true;
43729                         case 3: v(var.as<Cause>()); return true;
43730                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
43731                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
43732                         }
43733                         return false;
43734
43735                 }
43736                 private:
43737                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
43738                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
43739                 union union_type
43740                 {
43741                         char dummy1[sizeof(Cause)];
43742                         char dummy2[sizeof(UE_X2AP_ID)];
43743                         char dummy3[sizeof(UE_X2AP_ID_Extension)];
43744
43745                 };
43746                 asn::variant<sizeof(union_type)> var;
43747                 size_t type {0};
43748
43749         };
43750         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
43751         {
43752                 size_t get_index() const {return type;}
43753                 bool is_unknown() const { return type == 6; }
43754                 void clear() {type = 0;}
43755                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
43756                 void select_id_New_eNB_UE_X2AP_ID() { set(optional); type=2;}
43757                 void select_id_Cause() { set(mandatory); type=3;}
43758                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
43759                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
43760                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
43761                 template<typename V>  bool decode(V& v)
43762                 {
43763                         clear();
43764                         if(!v(ref_nested())) return false;
43765                         if(equal(mandatory)) { type = 1; return true; }
43766                         else if(equal(optional)) { type = 2; return true; }
43767                         else if(equal(mandatory)) { type = 3; return true; }
43768                         else if(equal(optional)) { type = 4; return true; }
43769                         else if(equal(optional)) { type = 5; return true; }
43770                         else { type = 6; return true;}
43771                         return false;
43772
43773                 }
43774                 template<typename V> bool encode(V& v) const
43775                 {
43776                         return v(ref_nested());
43777
43778                 }
43779                 protected:
43780                 template<typename V>  bool decode(size_t index, V& v)
43781                 {
43782                         clear();
43783                         switch(index)
43784                         {
43785                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
43786                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
43787                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
43788                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
43789                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
43790                         case 6: type = 6; return v(ref_nested());
43791                         ref_nested().clear();
43792                         }
43793                         return false;
43794
43795                 }
43796                 template<typename V> bool encode(size_t index, V& v) const
43797                 {
43798                         if(index != type) {return false;} return v(ref_nested());
43799
43800                 }
43801                 private:
43802                 size_t type {0};
43803
43804         };
43805
43806 };
43807 /*
43808 HandoverCancel ::= SEQUENCE {
43809         protocolIEs             ProtocolIE-Container    {{HandoverCancel-IEs}},
43810         ...
43811 }
43812 */
43813
43814 struct HandoverCancel : asn::sequence<1, 0, true, 0>
43815 {
43816         static constexpr const char* name() {return "HandoverCancel";}
43817         using parent_t = asn::sequence<1, 0, true, 0>;
43818         struct protocolIEs_t : ProtocolIE_Container<HandoverCancel_IEs>
43819         {
43820                 static constexpr const char* name() {return "protocolIEs_t";}
43821                 using parent_t = ProtocolIE_Container<HandoverCancel_IEs>;
43822
43823         };
43824         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
43825         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
43826         template<typename V> void decode(V& v)
43827         {
43828                 v(protocolIEs);
43829
43830         };
43831         template<typename V> void encode(V& v) const
43832         {
43833                 v(protocolIEs);
43834
43835         };
43836         void clear()
43837         {
43838                 protocolIEs.clear();
43839
43840         };
43841         private:
43842         protocolIEs_t   protocolIEs;
43843
43844 };
43845 /*
43846 HandoverPreparationFailure-IEs X2AP-PROTOCOL-IES ::= {
43847         { ID id-Old-eNB-UE-X2AP-ID                              CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
43848         { ID id-Cause                                                   CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
43849         { ID id-CriticalityDiagnostics                  CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
43850         { ID id-Old-eNB-UE-X2AP-ID-Extension    CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
43851
43852         ...
43853 }
43854 */
43855
43856 struct HandoverPreparationFailure_IEs
43857 {
43858         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
43859         {
43860                 size_t get_index() const {return type;}
43861                 bool is_unknown() const { return type == 5; }
43862                 void clear() {type = 0;}
43863                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
43864                 void select_id_Cause() { set(id_Cause); type=2;}
43865                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
43866                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
43867                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
43868                 template<typename V>  bool decode(V& v)
43869                 {
43870                         clear();
43871                         if(!v(ref_nested())) return false;
43872                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
43873                         else if(equal(id_Cause)) { type = 2; return true; }
43874                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
43875                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
43876                         else { type = 5; return true;}
43877                         return false;
43878
43879                 }
43880                 template<typename V> bool encode(V& v) const
43881                 {
43882                         return v(ref_nested());
43883
43884                 }
43885                 protected:
43886                 template<typename V>  bool decode(size_t index, V& v)
43887                 {
43888                         clear();
43889                         switch(index)
43890                         {
43891                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
43892                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
43893                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
43894                         case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
43895                         case 5: type = 5; return v(ref_nested());
43896                         ref_nested().clear();
43897                         }
43898                         return false;
43899
43900                 }
43901                 template<typename V> bool encode(size_t index, V& v) const
43902                 {
43903                         if(index != type) {return false;} return v(ref_nested());
43904
43905                 }
43906                 private:
43907                 size_t type {0};
43908
43909         };
43910         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
43911         {
43912                 size_t get_index() const {return type;}
43913                 bool is_unknown() const { return type == 5; }
43914                 void clear() {type = 0;}
43915                 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
43916                 void select_id_Cause() { set(ignore); type=2;}
43917                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
43918                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
43919                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
43920                 template<typename V>  bool decode(V& v)
43921                 {
43922                         clear();
43923                         if(!v(ref_nested())) return false;
43924                         if(equal(ignore)) { type = 1; return true; }
43925                         else if(equal(ignore)) { type = 2; return true; }
43926                         else if(equal(ignore)) { type = 3; return true; }
43927                         else if(equal(ignore)) { type = 4; return true; }
43928                         else { type = 5; return true;}
43929                         return false;
43930
43931                 }
43932                 template<typename V> bool encode(V& v) const
43933                 {
43934                         return v(ref_nested());
43935
43936                 }
43937                 protected:
43938                 template<typename V>  bool decode(size_t index, V& v)
43939                 {
43940                         clear();
43941                         switch(index)
43942                         {
43943                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
43944                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
43945                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
43946                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
43947                         case 5: type = 5; return v(ref_nested());
43948                         ref_nested().clear();
43949                         }
43950                         return false;
43951
43952                 }
43953                 template<typename V> bool encode(size_t index, V& v) const
43954                 {
43955                         if(index != type) {return false;} return v(ref_nested());
43956
43957                 }
43958                 private:
43959                 size_t type {0};
43960
43961         };
43962         struct Value_t : asn::typefield<true>
43963         {
43964                 ~Value_t()      {clear();}
43965                 size_t get_index() const {return type;}
43966                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
43967                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
43968                 Cause& select_id_Cause() { return set<Cause>(2); }
43969                 Cause const* get_id_Cause() const { return get<Cause>(2); }
43970                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
43971                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
43972                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
43973                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
43974                 bool is_unknown() const { return type == 5; }
43975                 void clear()
43976                 {
43977                         switch(type)
43978                         {
43979                         case 1: var.destroy<UE_X2AP_ID>(); break;
43980                         case 2: var.destroy<Cause>(); break;
43981                         case 3: var.destroy<CriticalityDiagnostics>(); break;
43982                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
43983                         }
43984                         type = 0; ref_nested().clear();
43985                 }
43986                 template<typename V> static inline void enumerate(V& v)
43987                 {
43988                         v.template operator()<UE_X2AP_ID>(1);
43989                         v.template operator()<Cause>(2);
43990                         v.template operator()<CriticalityDiagnostics>(3);
43991                         v.template operator()<UE_X2AP_ID_Extension>(4);
43992
43993                 }
43994                 protected:
43995                 template<typename V> bool decode(size_t index, V& v)
43996                 {
43997                         clear();
43998                         switch(index)
43999                         {
44000                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
44001                         case 2: v(select_id_Cause()); return true;
44002                         case 3: v(select_id_CriticalityDiagnostics()); return true;
44003                         case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
44004                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
44005                         }
44006                         return false;
44007
44008                 }
44009                 template<typename V> bool encode(size_t index, V& v) const
44010                 {
44011                         if(index != type) return false;
44012                         switch(type)
44013                         {
44014                         case 1: v(var.as<UE_X2AP_ID>()); return true;
44015                         case 2: v(var.as<Cause>()); return true;
44016                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
44017                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
44018                         }
44019                         return false;
44020
44021                 }
44022                 private:
44023                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44024                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44025                 union union_type
44026                 {
44027                         char dummy1[sizeof(Cause)];
44028                         char dummy2[sizeof(CriticalityDiagnostics)];
44029                         char dummy3[sizeof(UE_X2AP_ID)];
44030                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
44031
44032                 };
44033                 asn::variant<sizeof(union_type)> var;
44034                 size_t type {0};
44035
44036         };
44037         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
44038         {
44039                 size_t get_index() const {return type;}
44040                 bool is_unknown() const { return type == 5; }
44041                 void clear() {type = 0;}
44042                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
44043                 void select_id_Cause() { set(mandatory); type=2;}
44044                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
44045                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
44046                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
44047                 template<typename V>  bool decode(V& v)
44048                 {
44049                         clear();
44050                         if(!v(ref_nested())) return false;
44051                         if(equal(mandatory)) { type = 1; return true; }
44052                         else if(equal(mandatory)) { type = 2; return true; }
44053                         else if(equal(optional)) { type = 3; return true; }
44054                         else if(equal(optional)) { type = 4; return true; }
44055                         else { type = 5; return true;}
44056                         return false;
44057
44058                 }
44059                 template<typename V> bool encode(V& v) const
44060                 {
44061                         return v(ref_nested());
44062
44063                 }
44064                 protected:
44065                 template<typename V>  bool decode(size_t index, V& v)
44066                 {
44067                         clear();
44068                         switch(index)
44069                         {
44070                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
44071                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
44072                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
44073                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
44074                         case 5: type = 5; return v(ref_nested());
44075                         ref_nested().clear();
44076                         }
44077                         return false;
44078
44079                 }
44080                 template<typename V> bool encode(size_t index, V& v) const
44081                 {
44082                         if(index != type) {return false;} return v(ref_nested());
44083
44084                 }
44085                 private:
44086                 size_t type {0};
44087
44088         };
44089
44090 };
44091 /*
44092 HandoverPreparationFailure ::= SEQUENCE {
44093         protocolIEs             ProtocolIE-Container    {{HandoverPreparationFailure-IEs}},
44094         ...
44095 }
44096 */
44097
44098 struct HandoverPreparationFailure : asn::sequence<1, 0, true, 0>
44099 {
44100         static constexpr const char* name() {return "HandoverPreparationFailure";}
44101         using parent_t = asn::sequence<1, 0, true, 0>;
44102         struct protocolIEs_t : ProtocolIE_Container<HandoverPreparationFailure_IEs>
44103         {
44104                 static constexpr const char* name() {return "protocolIEs_t";}
44105                 using parent_t = ProtocolIE_Container<HandoverPreparationFailure_IEs>;
44106
44107         };
44108         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
44109         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
44110         template<typename V> void decode(V& v)
44111         {
44112                 v(protocolIEs);
44113
44114         };
44115         template<typename V> void encode(V& v) const
44116         {
44117                 v(protocolIEs);
44118
44119         };
44120         void clear()
44121         {
44122                 protocolIEs.clear();
44123
44124         };
44125         private:
44126         protocolIEs_t   protocolIEs;
44127
44128 };
44129 /*
44130 MobilityInformation ::= BIT STRING (SIZE(32))
44131 */
44132
44133 struct MobilityInformation : asn::bstring<>
44134 {
44135         using constraint_t = asn::constraints<false,asn::one<32>>;
44136         static constexpr const char* name() {return "MobilityInformation";}
44137         using parent_t = asn::bstring<>;
44138
44139 };
44140
44141 /*
44142 HandoverReport-IEs X2AP-PROTOCOL-IES ::= {
44143         { ID id-HandoverReportType                                                      CRITICALITY ignore      TYPE HandoverReportType                                                                 PRESENCE mandatory}|
44144         { ID id-Cause                                                                           CRITICALITY ignore      TYPE Cause                                                                                                      PRESENCE mandatory}|
44145         { ID id-SourceCellECGI                                                          CRITICALITY ignore      TYPE ECGI                                                                                                       PRESENCE mandatory}|
44146         { ID id-FailureCellECGI                                                         CRITICALITY ignore      TYPE ECGI                                                                                                       PRESENCE mandatory}|
44147         { ID id-Re-establishmentCellECGI                                        CRITICALITY ignore      TYPE ECGI                                                                                                       PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to “HO to Wrong Cell” -- |
44148         { ID id-TargetCellInUTRAN                                                       CRITICALITY ignore      TYPE TargetCellInUTRAN                                                                  PRESENCE conditional} -- The IE shall be present if the Handover Report Type IE is set to "InterRAT ping-pong" --|
44149         { ID id-SourceCellCRNTI                                                         CRITICALITY ignore      TYPE CRNTI                                                                                                      PRESENCE optional}|
44150         { ID id-MobilityInformation                                                     CRITICALITY ignore      TYPE MobilityInformation                                                                        PRESENCE optional}|
44151         { ID id-UE-RLF-Report-Container                                         CRITICALITY ignore      TYPE UE-RLF-Report-Container                                                    PRESENCE optional}|
44152         { ID id-UE-RLF-Report-Container-for-extended-bands      CRITICALITY ignore      TYPE UE-RLF-Report-Container-for-extended-bands PRESENCE optional},
44153         ...
44154 }
44155 */
44156
44157 struct HandoverReport_IEs
44158 {
44159         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
44160         {
44161                 size_t get_index() const {return type;}
44162                 bool is_unknown() const { return type == 11; }
44163                 void clear() {type = 0;}
44164                 void select_id_HandoverReportType() { set(id_HandoverReportType); type=1;}
44165                 void select_id_Cause() { set(id_Cause); type=2;}
44166                 void select_id_SourceCellECGI() { set(id_SourceCellECGI); type=3;}
44167                 void select_id_FailureCellECGI() { set(id_FailureCellECGI); type=4;}
44168                 void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=5;}
44169                 void select_id_TargetCellInUTRAN() { set(id_TargetCellInUTRAN); type=6;}
44170                 void select_id_SourceCellCRNTI() { set(id_SourceCellCRNTI); type=7;}
44171                 void select_id_MobilityInformation() { set(id_MobilityInformation); type=8;}
44172                 void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=9;}
44173                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=10;}
44174                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
44175                 template<typename V>  bool decode(V& v)
44176                 {
44177                         clear();
44178                         if(!v(ref_nested())) return false;
44179                         if(equal(id_HandoverReportType)) { type = 1; return true; }
44180                         else if(equal(id_Cause)) { type = 2; return true; }
44181                         else if(equal(id_SourceCellECGI)) { type = 3; return true; }
44182                         else if(equal(id_FailureCellECGI)) { type = 4; return true; }
44183                         else if(equal(id_Re_establishmentCellECGI)) { type = 5; return true; }
44184                         else if(equal(id_TargetCellInUTRAN)) { type = 6; return true; }
44185                         else if(equal(id_SourceCellCRNTI)) { type = 7; return true; }
44186                         else if(equal(id_MobilityInformation)) { type = 8; return true; }
44187                         else if(equal(id_UE_RLF_Report_Container)) { type = 9; return true; }
44188                         else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 10; return true; }
44189                         else { type = 11; return true;}
44190                         return false;
44191
44192                 }
44193                 template<typename V> bool encode(V& v) const
44194                 {
44195                         return v(ref_nested());
44196
44197                 }
44198                 protected:
44199                 template<typename V>  bool decode(size_t index, V& v)
44200                 {
44201                         clear();
44202                         switch(index)
44203                         {
44204                         case 1: type = 1; if(v(ref_nested())) { return equal(id_HandoverReportType);} return false;
44205                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
44206                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SourceCellECGI);} return false;
44207                         case 4: type = 4; if(v(ref_nested())) { return equal(id_FailureCellECGI);} return false;
44208                         case 5: type = 5; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
44209                         case 6: type = 6; if(v(ref_nested())) { return equal(id_TargetCellInUTRAN);} return false;
44210                         case 7: type = 7; if(v(ref_nested())) { return equal(id_SourceCellCRNTI);} return false;
44211                         case 8: type = 8; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
44212                         case 9: type = 9; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
44213                         case 10: type = 10; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
44214                         case 11: type = 11; return v(ref_nested());
44215                         ref_nested().clear();
44216                         }
44217                         return false;
44218
44219                 }
44220                 template<typename V> bool encode(size_t index, V& v) const
44221                 {
44222                         if(index != type) {return false;} return v(ref_nested());
44223
44224                 }
44225                 private:
44226                 size_t type {0};
44227
44228         };
44229         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
44230         {
44231                 size_t get_index() const {return type;}
44232                 bool is_unknown() const { return type == 11; }
44233                 void clear() {type = 0;}
44234                 void select_id_HandoverReportType() { set(ignore); type=1;}
44235                 void select_id_Cause() { set(ignore); type=2;}
44236                 void select_id_SourceCellECGI() { set(ignore); type=3;}
44237                 void select_id_FailureCellECGI() { set(ignore); type=4;}
44238                 void select_id_Re_establishmentCellECGI() { set(ignore); type=5;}
44239                 void select_id_TargetCellInUTRAN() { set(ignore); type=6;}
44240                 void select_id_SourceCellCRNTI() { set(ignore); type=7;}
44241                 void select_id_MobilityInformation() { set(ignore); type=8;}
44242                 void select_id_UE_RLF_Report_Container() { set(ignore); type=9;}
44243                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=10;}
44244                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
44245                 template<typename V>  bool decode(V& v)
44246                 {
44247                         clear();
44248                         if(!v(ref_nested())) return false;
44249                         if(equal(ignore)) { type = 1; return true; }
44250                         else if(equal(ignore)) { type = 2; return true; }
44251                         else if(equal(ignore)) { type = 3; return true; }
44252                         else if(equal(ignore)) { type = 4; return true; }
44253                         else if(equal(ignore)) { type = 5; return true; }
44254                         else if(equal(ignore)) { type = 6; return true; }
44255                         else if(equal(ignore)) { type = 7; return true; }
44256                         else if(equal(ignore)) { type = 8; return true; }
44257                         else if(equal(ignore)) { type = 9; return true; }
44258                         else if(equal(ignore)) { type = 10; return true; }
44259                         else { type = 11; return true;}
44260                         return false;
44261
44262                 }
44263                 template<typename V> bool encode(V& v) const
44264                 {
44265                         return v(ref_nested());
44266
44267                 }
44268                 protected:
44269                 template<typename V>  bool decode(size_t index, V& v)
44270                 {
44271                         clear();
44272                         switch(index)
44273                         {
44274                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
44275                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
44276                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
44277                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
44278                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
44279                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
44280                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
44281                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
44282                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
44283                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
44284                         case 11: type = 11; return v(ref_nested());
44285                         ref_nested().clear();
44286                         }
44287                         return false;
44288
44289                 }
44290                 template<typename V> bool encode(size_t index, V& v) const
44291                 {
44292                         if(index != type) {return false;} return v(ref_nested());
44293
44294                 }
44295                 private:
44296                 size_t type {0};
44297
44298         };
44299         struct Value_t : asn::typefield<true>
44300         {
44301                 ~Value_t()      {clear();}
44302                 size_t get_index() const {return type;}
44303                 HandoverReportType& select_id_HandoverReportType() { return set<HandoverReportType>(1); }
44304                 HandoverReportType const* get_id_HandoverReportType() const { return get<HandoverReportType>(1); }
44305                 Cause& select_id_Cause() { return set<Cause>(2); }
44306                 Cause const* get_id_Cause() const { return get<Cause>(2); }
44307                 ECGI& select_id_SourceCellECGI() { return set<ECGI>(3); }
44308                 ECGI const* get_id_SourceCellECGI() const { return get<ECGI>(3); }
44309                 ECGI& select_id_FailureCellECGI() { return set<ECGI>(4); }
44310                 ECGI const* get_id_FailureCellECGI() const { return get<ECGI>(4); }
44311                 ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(5); }
44312                 ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(5); }
44313                 TargetCellInUTRAN& select_id_TargetCellInUTRAN() { return set<TargetCellInUTRAN>(6); }
44314                 TargetCellInUTRAN const* get_id_TargetCellInUTRAN() const { return get<TargetCellInUTRAN>(6); }
44315                 CRNTI& select_id_SourceCellCRNTI() { return set<CRNTI>(7); }
44316                 CRNTI const* get_id_SourceCellCRNTI() const { return get<CRNTI>(7); }
44317                 MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(8); }
44318                 MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(8); }
44319                 UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(9); }
44320                 UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(9); }
44321                 UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(10); }
44322                 UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(10); }
44323                 bool is_unknown() const { return type == 11; }
44324                 void clear()
44325                 {
44326                         switch(type)
44327                         {
44328                         case 1: var.destroy<HandoverReportType>(); break;
44329                         case 2: var.destroy<Cause>(); break;
44330                         case 3: var.destroy<ECGI>(); break;
44331                         case 4: var.destroy<ECGI>(); break;
44332                         case 5: var.destroy<ECGI>(); break;
44333                         case 6: var.destroy<TargetCellInUTRAN>(); break;
44334                         case 7: var.destroy<CRNTI>(); break;
44335                         case 8: var.destroy<MobilityInformation>(); break;
44336                         case 9: var.destroy<UE_RLF_Report_Container>(); break;
44337                         case 10: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
44338                         }
44339                         type = 0; ref_nested().clear();
44340                 }
44341                 template<typename V> static inline void enumerate(V& v)
44342                 {
44343                         v.template operator()<HandoverReportType>(1);
44344                         v.template operator()<Cause>(2);
44345                         v.template operator()<ECGI>(3);
44346                         v.template operator()<ECGI>(4);
44347                         v.template operator()<ECGI>(5);
44348                         v.template operator()<TargetCellInUTRAN>(6);
44349                         v.template operator()<CRNTI>(7);
44350                         v.template operator()<MobilityInformation>(8);
44351                         v.template operator()<UE_RLF_Report_Container>(9);
44352                         v.template operator()<UE_RLF_Report_Container_for_extended_bands>(10);
44353
44354                 }
44355                 protected:
44356                 template<typename V> bool decode(size_t index, V& v)
44357                 {
44358                         clear();
44359                         switch(index)
44360                         {
44361                         case 1: v(select_id_HandoverReportType()); return true;
44362                         case 2: v(select_id_Cause()); return true;
44363                         case 3: v(select_id_SourceCellECGI()); return true;
44364                         case 4: v(select_id_FailureCellECGI()); return true;
44365                         case 5: v(select_id_Re_establishmentCellECGI()); return true;
44366                         case 6: v(select_id_TargetCellInUTRAN()); return true;
44367                         case 7: v(select_id_SourceCellCRNTI()); return true;
44368                         case 8: v(select_id_MobilityInformation()); return true;
44369                         case 9: v(select_id_UE_RLF_Report_Container()); return true;
44370                         case 10: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
44371                         case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
44372                         }
44373                         return false;
44374
44375                 }
44376                 template<typename V> bool encode(size_t index, V& v) const
44377                 {
44378                         if(index != type) return false;
44379                         switch(type)
44380                         {
44381                         case 1: v(var.as<HandoverReportType>()); return true;
44382                         case 2: v(var.as<Cause>()); return true;
44383                         case 3: v(var.as<ECGI>()); return true;
44384                         case 4: v(var.as<ECGI>()); return true;
44385                         case 5: v(var.as<ECGI>()); return true;
44386                         case 6: v(var.as<TargetCellInUTRAN>()); return true;
44387                         case 7: v(var.as<CRNTI>()); return true;
44388                         case 8: v(var.as<MobilityInformation>()); return true;
44389                         case 9: v(var.as<UE_RLF_Report_Container>()); return true;
44390                         case 10: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); return true;
44391                         }
44392                         return false;
44393
44394                 }
44395                 private:
44396                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44397                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44398                 union union_type
44399                 {
44400                         char dummy1[sizeof(CRNTI)];
44401                         char dummy2[sizeof(Cause)];
44402                         char dummy3[sizeof(ECGI)];
44403                         char dummy4[sizeof(HandoverReportType)];
44404                         char dummy5[sizeof(MobilityInformation)];
44405                         char dummy6[sizeof(TargetCellInUTRAN)];
44406                         char dummy7[sizeof(UE_RLF_Report_Container)];
44407                         char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
44408
44409                 };
44410                 asn::variant<sizeof(union_type)> var;
44411                 size_t type {0};
44412
44413         };
44414         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
44415         {
44416                 size_t get_index() const {return type;}
44417                 bool is_unknown() const { return type == 11; }
44418                 void clear() {type = 0;}
44419                 void select_id_HandoverReportType() { set(mandatory); type=1;}
44420                 void select_id_Cause() { set(mandatory); type=2;}
44421                 void select_id_SourceCellECGI() { set(mandatory); type=3;}
44422                 void select_id_FailureCellECGI() { set(mandatory); type=4;}
44423                 void select_id_Re_establishmentCellECGI() { set(conditional); type=5;}
44424                 void select_id_TargetCellInUTRAN() { set(conditional); type=6;}
44425                 void select_id_SourceCellCRNTI() { set(optional); type=7;}
44426                 void select_id_MobilityInformation() { set(optional); type=8;}
44427                 void select_id_UE_RLF_Report_Container() { set(optional); type=9;}
44428                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=10;}
44429                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
44430                 template<typename V>  bool decode(V& v)
44431                 {
44432                         clear();
44433                         if(!v(ref_nested())) return false;
44434                         if(equal(mandatory)) { type = 1; return true; }
44435                         else if(equal(mandatory)) { type = 2; return true; }
44436                         else if(equal(mandatory)) { type = 3; return true; }
44437                         else if(equal(mandatory)) { type = 4; return true; }
44438                         else if(equal(conditional)) { type = 5; return true; }
44439                         else if(equal(conditional)) { type = 6; return true; }
44440                         else if(equal(optional)) { type = 7; return true; }
44441                         else if(equal(optional)) { type = 8; return true; }
44442                         else if(equal(optional)) { type = 9; return true; }
44443                         else if(equal(optional)) { type = 10; return true; }
44444                         else { type = 11; return true;}
44445                         return false;
44446
44447                 }
44448                 template<typename V> bool encode(V& v) const
44449                 {
44450                         return v(ref_nested());
44451
44452                 }
44453                 protected:
44454                 template<typename V>  bool decode(size_t index, V& v)
44455                 {
44456                         clear();
44457                         switch(index)
44458                         {
44459                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
44460                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
44461                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
44462                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
44463                         case 5: type = 5; if(v(ref_nested())) { return equal(conditional);} return false;
44464                         case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
44465                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
44466                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
44467                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
44468                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
44469                         case 11: type = 11; return v(ref_nested());
44470                         ref_nested().clear();
44471                         }
44472                         return false;
44473
44474                 }
44475                 template<typename V> bool encode(size_t index, V& v) const
44476                 {
44477                         if(index != type) {return false;} return v(ref_nested());
44478
44479                 }
44480                 private:
44481                 size_t type {0};
44482
44483         };
44484
44485 };
44486 /*
44487 HandoverReport ::= SEQUENCE {
44488         protocolIEs             ProtocolIE-Container    {{HandoverReport-IEs}},
44489         ...
44490 }
44491 */
44492
44493 struct HandoverReport : asn::sequence<1, 0, true, 0>
44494 {
44495         static constexpr const char* name() {return "HandoverReport";}
44496         using parent_t = asn::sequence<1, 0, true, 0>;
44497         struct protocolIEs_t : ProtocolIE_Container<HandoverReport_IEs>
44498         {
44499                 static constexpr const char* name() {return "protocolIEs_t";}
44500                 using parent_t = ProtocolIE_Container<HandoverReport_IEs>;
44501
44502         };
44503         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
44504         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
44505         template<typename V> void decode(V& v)
44506         {
44507                 v(protocolIEs);
44508
44509         };
44510         template<typename V> void encode(V& v) const
44511         {
44512                 v(protocolIEs);
44513
44514         };
44515         void clear()
44516         {
44517                 protocolIEs.clear();
44518
44519         };
44520         private:
44521         protocolIEs_t   protocolIEs;
44522
44523 };
44524 /*
44525 UE-ContextInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
44526 { ID id-ManagementBasedMDTallowed                       CRITICALITY ignore      EXTENSION ManagementBasedMDTallowed                                     PRESENCE optional }|
44527 { ID id-ManagementBasedMDTPLMNList                      CRITICALITY ignore      EXTENSION MDTPLMNList                                                                   PRESENCE optional }|
44528 { ID id-UESidelinkAggregateMaximumBitRate       CRITICALITY ignore      EXTENSION UESidelinkAggregateMaximumBitRate             PRESENCE optional},
44529         ...
44530 }
44531 */
44532
44533 struct UE_ContextInformation_ExtIEs
44534 {
44535         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
44536         {
44537                 size_t get_index() const {return type;}
44538                 bool is_unknown() const { return type == 4; }
44539                 void clear() {type = 0;}
44540                 void select_id_ManagementBasedMDTallowed() { set(id_ManagementBasedMDTallowed); type=1;}
44541                 void select_id_ManagementBasedMDTPLMNList() { set(id_ManagementBasedMDTPLMNList); type=2;}
44542                 void select_id_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); type=3;}
44543                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
44544                 template<typename V>  bool decode(V& v)
44545                 {
44546                         clear();
44547                         if(!v(ref_nested())) return false;
44548                         if(equal(id_ManagementBasedMDTallowed)) { type = 1; return true; }
44549                         else if(equal(id_ManagementBasedMDTPLMNList)) { type = 2; return true; }
44550                         else if(equal(id_UESidelinkAggregateMaximumBitRate)) { type = 3; return true; }
44551                         else { type = 4; return true;}
44552                         return false;
44553
44554                 }
44555                 template<typename V> bool encode(V& v) const
44556                 {
44557                         return v(ref_nested());
44558
44559                 }
44560                 protected:
44561                 template<typename V>  bool decode(size_t index, V& v)
44562                 {
44563                         clear();
44564                         switch(index)
44565                         {
44566                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ManagementBasedMDTallowed);} return false;
44567                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ManagementBasedMDTPLMNList);} return false;
44568                         case 3: type = 3; if(v(ref_nested())) { return equal(id_UESidelinkAggregateMaximumBitRate);} return false;
44569                         case 4: type = 4; return v(ref_nested());
44570                         ref_nested().clear();
44571                         }
44572                         return false;
44573
44574                 }
44575                 template<typename V> bool encode(size_t index, V& v) const
44576                 {
44577                         if(index != type) {return false;} return v(ref_nested());
44578
44579                 }
44580                 private:
44581                 size_t type {0};
44582
44583         };
44584         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
44585         {
44586                 size_t get_index() const {return type;}
44587                 bool is_unknown() const { return type == 4; }
44588                 void clear() {type = 0;}
44589                 void select_id_ManagementBasedMDTallowed() { set(ignore); type=1;}
44590                 void select_id_ManagementBasedMDTPLMNList() { set(ignore); type=2;}
44591                 void select_id_UESidelinkAggregateMaximumBitRate() { set(ignore); type=3;}
44592                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
44593                 template<typename V>  bool decode(V& v)
44594                 {
44595                         clear();
44596                         if(!v(ref_nested())) return false;
44597                         if(equal(ignore)) { type = 1; return true; }
44598                         else if(equal(ignore)) { type = 2; return true; }
44599                         else if(equal(ignore)) { type = 3; return true; }
44600                         else { type = 4; return true;}
44601                         return false;
44602
44603                 }
44604                 template<typename V> bool encode(V& v) const
44605                 {
44606                         return v(ref_nested());
44607
44608                 }
44609                 protected:
44610                 template<typename V>  bool decode(size_t index, V& v)
44611                 {
44612                         clear();
44613                         switch(index)
44614                         {
44615                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
44616                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
44617                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
44618                         case 4: type = 4; return v(ref_nested());
44619                         ref_nested().clear();
44620                         }
44621                         return false;
44622
44623                 }
44624                 template<typename V> bool encode(size_t index, V& v) const
44625                 {
44626                         if(index != type) {return false;} return v(ref_nested());
44627
44628                 }
44629                 private:
44630                 size_t type {0};
44631
44632         };
44633         struct Extension_t : asn::typefield<true>
44634         {
44635                 ~Extension_t()  {clear();}
44636                 size_t get_index() const {return type;}
44637                 ManagementBasedMDTallowed& select_id_ManagementBasedMDTallowed() { return set<ManagementBasedMDTallowed>(1); }
44638                 ManagementBasedMDTallowed const* get_id_ManagementBasedMDTallowed() const { return get<ManagementBasedMDTallowed>(1); }
44639                 MDTPLMNList& select_id_ManagementBasedMDTPLMNList() { return set<MDTPLMNList>(2); }
44640                 MDTPLMNList const* get_id_ManagementBasedMDTPLMNList() const { return get<MDTPLMNList>(2); }
44641                 UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(3); }
44642                 UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(3); }
44643                 bool is_unknown() const { return type == 4; }
44644                 void clear()
44645                 {
44646                         switch(type)
44647                         {
44648                         case 1: var.destroy<ManagementBasedMDTallowed>(); break;
44649                         case 2: var.destroy<MDTPLMNList>(); break;
44650                         case 3: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
44651                         }
44652                         type = 0; ref_nested().clear();
44653                 }
44654                 template<typename V> static inline void enumerate(V& v)
44655                 {
44656                         v.template operator()<ManagementBasedMDTallowed>(1);
44657                         v.template operator()<MDTPLMNList>(2);
44658                         v.template operator()<UESidelinkAggregateMaximumBitRate>(3);
44659
44660                 }
44661                 protected:
44662                 template<typename V> bool decode(size_t index, V& v)
44663                 {
44664                         clear();
44665                         switch(index)
44666                         {
44667                         case 1: v(select_id_ManagementBasedMDTallowed()); return true;
44668                         case 2: v(select_id_ManagementBasedMDTPLMNList()); return true;
44669                         case 3: v(select_id_UESidelinkAggregateMaximumBitRate()); return true;
44670                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
44671                         }
44672                         return false;
44673
44674                 }
44675                 template<typename V> bool encode(size_t index, V& v) const
44676                 {
44677                         if(index != type) return false;
44678                         switch(type)
44679                         {
44680                         case 1: v(var.as<ManagementBasedMDTallowed>()); return true;
44681                         case 2: v(var.as<MDTPLMNList>()); return true;
44682                         case 3: v(var.as<UESidelinkAggregateMaximumBitRate>()); return true;
44683                         }
44684                         return false;
44685
44686                 }
44687                 private:
44688                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
44689                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
44690                 union union_type
44691                 {
44692                         char dummy1[sizeof(MDTPLMNList)];
44693                         char dummy2[sizeof(ManagementBasedMDTallowed)];
44694                         char dummy3[sizeof(UESidelinkAggregateMaximumBitRate)];
44695
44696                 };
44697                 asn::variant<sizeof(union_type)> var;
44698                 size_t type {0};
44699
44700         };
44701         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
44702         {
44703                 size_t get_index() const {return type;}
44704                 bool is_unknown() const { return type == 4; }
44705                 void clear() {type = 0;}
44706                 void select_id_ManagementBasedMDTallowed() { set(optional); type=1;}
44707                 void select_id_ManagementBasedMDTPLMNList() { set(optional); type=2;}
44708                 void select_id_UESidelinkAggregateMaximumBitRate() { set(optional); type=3;}
44709                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
44710                 template<typename V>  bool decode(V& v)
44711                 {
44712                         clear();
44713                         if(!v(ref_nested())) return false;
44714                         if(equal(optional)) { type = 1; return true; }
44715                         else if(equal(optional)) { type = 2; return true; }
44716                         else if(equal(optional)) { type = 3; return true; }
44717                         else { type = 4; return true;}
44718                         return false;
44719
44720                 }
44721                 template<typename V> bool encode(V& v) const
44722                 {
44723                         return v(ref_nested());
44724
44725                 }
44726                 protected:
44727                 template<typename V>  bool decode(size_t index, V& v)
44728                 {
44729                         clear();
44730                         switch(index)
44731                         {
44732                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
44733                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
44734                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
44735                         case 4: type = 4; return v(ref_nested());
44736                         ref_nested().clear();
44737                         }
44738                         return false;
44739
44740                 }
44741                 template<typename V> bool encode(size_t index, V& v) const
44742                 {
44743                         if(index != type) {return false;} return v(ref_nested());
44744
44745                 }
44746                 private:
44747                 size_t type {0};
44748
44749         };
44750
44751 };
44752 /*
44753 UE-ContextInformation ::= SEQUENCE {
44754         mME-UE-S1AP-ID                                          UE-S1AP-ID,
44755         uESecurityCapabilities                          UESecurityCapabilities,
44756         aS-SecurityInformation                          AS-SecurityInformation,
44757         uEaggregateMaximumBitRate                       UEAggregateMaximumBitRate,
44758         subscriberProfileIDforRFP                       SubscriberProfileIDforRFP               OPTIONAL,
44759         e-RABs-ToBeSetup-List                           E-RABs-ToBeSetup-List,
44760         rRC-Context                                                     RRC-Context,
44761         handoverRestrictionList                         HandoverRestrictionList         OPTIONAL,
44762         locationReportingInformation            LocationReportingInformation    OPTIONAL,
44763         iE-Extensions                                           ProtocolExtensionContainer { {UE-ContextInformation-ExtIEs} } OPTIONAL,
44764         ...
44765 }
44766 */
44767
44768 struct UE_ContextInformation : asn::sequence<10, 0, true, 4>
44769 {
44770         static constexpr const char* name() {return "UE-ContextInformation";}
44771         using parent_t = asn::sequence<10, 0, true, 4>;
44772         struct mME_UE_S1AP_ID_t : UE_S1AP_ID
44773         {
44774                 static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
44775                 using parent_t = UE_S1AP_ID;
44776
44777         };
44778         mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
44779         mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
44780         struct uESecurityCapabilities_t : UESecurityCapabilities
44781         {
44782                 static constexpr const char* name() {return "uESecurityCapabilities_t";}
44783                 using parent_t = UESecurityCapabilities;
44784
44785         };
44786         uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
44787         uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
44788         struct aS_SecurityInformation_t : AS_SecurityInformation
44789         {
44790                 static constexpr const char* name() {return "aS_SecurityInformation_t";}
44791                 using parent_t = AS_SecurityInformation;
44792
44793         };
44794         aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
44795         aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
44796         struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
44797         {
44798                 static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
44799                 using parent_t = UEAggregateMaximumBitRate;
44800
44801         };
44802         uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
44803         uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
44804         struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
44805         {
44806                 static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
44807                 using parent_t = SubscriberProfileIDforRFP;
44808                 static constexpr bool optional = true;
44809
44810         };
44811         subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
44812         subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
44813         struct e_RABs_ToBeSetup_List_t : E_RABs_ToBeSetup_List
44814         {
44815                 static constexpr const char* name() {return "e_RABs_ToBeSetup_List_t";}
44816                 using parent_t = E_RABs_ToBeSetup_List;
44817
44818         };
44819         e_RABs_ToBeSetup_List_t& ref_e_RABs_ToBeSetup_List() {return e_RABs_ToBeSetup_List;}
44820         e_RABs_ToBeSetup_List_t const& ref_e_RABs_ToBeSetup_List() const {return e_RABs_ToBeSetup_List;}
44821         struct rRC_Context_t : RRC_Context
44822         {
44823                 static constexpr const char* name() {return "rRC_Context_t";}
44824                 using parent_t = RRC_Context;
44825
44826         };
44827         rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
44828         rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
44829         struct handoverRestrictionList_t : HandoverRestrictionList
44830         {
44831                 static constexpr const char* name() {return "handoverRestrictionList_t";}
44832                 using parent_t = HandoverRestrictionList;
44833                 static constexpr bool optional = true;
44834
44835         };
44836         handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
44837         handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
44838         struct locationReportingInformation_t : LocationReportingInformation
44839         {
44840                 static constexpr const char* name() {return "locationReportingInformation_t";}
44841                 using parent_t = LocationReportingInformation;
44842                 static constexpr bool optional = true;
44843
44844         };
44845         locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
44846         locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
44847         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformation_ExtIEs>
44848         {
44849                 static constexpr const char* name() {return "iE_Extensions_t";}
44850                 using parent_t = ProtocolExtensionContainer<UE_ContextInformation_ExtIEs>;
44851                 static constexpr bool optional = true;
44852
44853         };
44854         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
44855         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
44856         template<typename V> void decode(V& v)
44857         {
44858                 v(mME_UE_S1AP_ID);
44859                 v(uESecurityCapabilities);
44860                 v(aS_SecurityInformation);
44861                 v(uEaggregateMaximumBitRate);
44862                 v(subscriberProfileIDforRFP);
44863                 v(e_RABs_ToBeSetup_List);
44864                 v(rRC_Context);
44865                 v(handoverRestrictionList);
44866                 v(locationReportingInformation);
44867                 v(iE_Extensions);
44868
44869         };
44870         template<typename V> void encode(V& v) const
44871         {
44872                 v(mME_UE_S1AP_ID);
44873                 v(uESecurityCapabilities);
44874                 v(aS_SecurityInformation);
44875                 v(uEaggregateMaximumBitRate);
44876                 v(subscriberProfileIDforRFP);
44877                 v(e_RABs_ToBeSetup_List);
44878                 v(rRC_Context);
44879                 v(handoverRestrictionList);
44880                 v(locationReportingInformation);
44881                 v(iE_Extensions);
44882
44883         };
44884         void clear()
44885         {
44886                 mME_UE_S1AP_ID.clear();
44887                 uESecurityCapabilities.clear();
44888                 aS_SecurityInformation.clear();
44889                 uEaggregateMaximumBitRate.clear();
44890                 subscriberProfileIDforRFP.clear();
44891                 e_RABs_ToBeSetup_List.clear();
44892                 rRC_Context.clear();
44893                 handoverRestrictionList.clear();
44894                 locationReportingInformation.clear();
44895                 iE_Extensions.clear();
44896
44897         };
44898         private:
44899         mME_UE_S1AP_ID_t        mME_UE_S1AP_ID;
44900         uESecurityCapabilities_t        uESecurityCapabilities;
44901         aS_SecurityInformation_t        aS_SecurityInformation;
44902         uEaggregateMaximumBitRate_t     uEaggregateMaximumBitRate;
44903         subscriberProfileIDforRFP_t     subscriberProfileIDforRFP;
44904         e_RABs_ToBeSetup_List_t e_RABs_ToBeSetup_List;
44905         rRC_Context_t   rRC_Context;
44906         handoverRestrictionList_t       handoverRestrictionList;
44907         locationReportingInformation_t  locationReportingInformation;
44908         iE_Extensions_t iE_Extensions;
44909
44910 };
44911 /*
44912 UE-ContextReferenceAtSeNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
44913         ...
44914 }
44915 */
44916
44917 struct UE_ContextReferenceAtSeNB_ItemExtIEs
44918 {
44919         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
44920         {
44921                 size_t get_index() const {return type;}
44922                 bool is_unknown() const { return type == 1; }
44923                 void clear() {type = 0;}
44924                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
44925                 template<typename V>  bool decode(V& v)
44926                 {
44927                         clear();
44928                         if(!v(ref_nested())) return false;
44929                         { type = 1; return true;}
44930                         return false;
44931
44932                 }
44933                 template<typename V> bool encode(V& v) const
44934                 {
44935                         return v(ref_nested());
44936
44937                 }
44938                 protected:
44939                 template<typename V>  bool decode(size_t index, V& v)
44940                 {
44941                         clear();
44942                         switch(index)
44943                         {
44944                         case 1: type = 1; return v(ref_nested());
44945                         ref_nested().clear();
44946                         }
44947                         return false;
44948
44949                 }
44950                 template<typename V> bool encode(size_t index, V& v) const
44951                 {
44952                         if(index != type) {return false;} return v(ref_nested());
44953
44954                 }
44955                 private:
44956                 size_t type {0};
44957
44958         };
44959         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
44960         {
44961                 size_t get_index() const {return type;}
44962                 bool is_unknown() const { return type == 1; }
44963                 void clear() {type = 0;}
44964                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
44965                 template<typename V>  bool decode(V& v)
44966                 {
44967                         clear();
44968                         if(!v(ref_nested())) return false;
44969                         { type = 1; return true;}
44970                         return false;
44971
44972                 }
44973                 template<typename V> bool encode(V& v) const
44974                 {
44975                         return v(ref_nested());
44976
44977                 }
44978                 protected:
44979                 template<typename V>  bool decode(size_t index, V& v)
44980                 {
44981                         clear();
44982                         switch(index)
44983                         {
44984                         case 1: type = 1; return v(ref_nested());
44985                         ref_nested().clear();
44986                         }
44987                         return false;
44988
44989                 }
44990                 template<typename V> bool encode(size_t index, V& v) const
44991                 {
44992                         if(index != type) {return false;} return v(ref_nested());
44993
44994                 }
44995                 private:
44996                 size_t type {0};
44997
44998         };
44999         struct Extension_t : asn::typefield<true>
45000         {
45001                 ~Extension_t()  {clear();}
45002                 size_t get_index() const {return type;}
45003                 bool is_unknown() const { return type == 1; }
45004                 void clear()
45005                 {
45006                         type = 0; ref_nested().clear();
45007                 }
45008                 template<typename V> static inline void enumerate(V& v)
45009                 {
45010
45011                 }
45012                 protected:
45013                 template<typename V> bool decode(size_t index, V& v)
45014                 {
45015                         clear();
45016                         switch(index)
45017                         {
45018                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45019                         }
45020                         return false;
45021
45022                 }
45023                 template<typename V> bool encode(size_t index, V& v) const
45024                 {
45025                         if(index != type) return false;
45026                         return false;
45027
45028                 }
45029                 private:
45030                 size_t type {0};
45031
45032         };
45033         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45034         {
45035                 size_t get_index() const {return type;}
45036                 bool is_unknown() const { return type == 1; }
45037                 void clear() {type = 0;}
45038                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45039                 template<typename V>  bool decode(V& v)
45040                 {
45041                         clear();
45042                         if(!v(ref_nested())) return false;
45043                         { type = 1; return true;}
45044                         return false;
45045
45046                 }
45047                 template<typename V> bool encode(V& v) const
45048                 {
45049                         return v(ref_nested());
45050
45051                 }
45052                 protected:
45053                 template<typename V>  bool decode(size_t index, V& v)
45054                 {
45055                         clear();
45056                         switch(index)
45057                         {
45058                         case 1: type = 1; return v(ref_nested());
45059                         ref_nested().clear();
45060                         }
45061                         return false;
45062
45063                 }
45064                 template<typename V> bool encode(size_t index, V& v) const
45065                 {
45066                         if(index != type) {return false;} return v(ref_nested());
45067
45068                 }
45069                 private:
45070                 size_t type {0};
45071
45072         };
45073
45074 };
45075 /*
45076 UE-ContextReferenceAtSeNB ::= SEQUENCE {
45077         source-GlobalSeNB-ID            GlobalENB-ID,
45078         seNB-UE-X2AP-ID                         UE-X2AP-ID,
45079         seNB-UE-X2AP-ID-Extension       UE-X2AP-ID-Extension,
45080         iE-Extensions                           ProtocolExtensionContainer { {UE-ContextReferenceAtSeNB-ItemExtIEs} } OPTIONAL,
45081         ...
45082 }
45083 */
45084
45085 struct UE_ContextReferenceAtSeNB : asn::sequence<4, 0, true, 1>
45086 {
45087         static constexpr const char* name() {return "UE-ContextReferenceAtSeNB";}
45088         using parent_t = asn::sequence<4, 0, true, 1>;
45089         struct source_GlobalSeNB_ID_t : GlobalENB_ID
45090         {
45091                 static constexpr const char* name() {return "source_GlobalSeNB_ID_t";}
45092                 using parent_t = GlobalENB_ID;
45093
45094         };
45095         source_GlobalSeNB_ID_t& ref_source_GlobalSeNB_ID() {return source_GlobalSeNB_ID;}
45096         source_GlobalSeNB_ID_t const& ref_source_GlobalSeNB_ID() const {return source_GlobalSeNB_ID;}
45097         struct seNB_UE_X2AP_ID_t : UE_X2AP_ID
45098         {
45099                 static constexpr const char* name() {return "seNB_UE_X2AP_ID_t";}
45100                 using parent_t = UE_X2AP_ID;
45101
45102         };
45103         seNB_UE_X2AP_ID_t& ref_seNB_UE_X2AP_ID() {return seNB_UE_X2AP_ID;}
45104         seNB_UE_X2AP_ID_t const& ref_seNB_UE_X2AP_ID() const {return seNB_UE_X2AP_ID;}
45105         struct seNB_UE_X2AP_ID_Extension_t : UE_X2AP_ID_Extension
45106         {
45107                 static constexpr const char* name() {return "seNB_UE_X2AP_ID_Extension_t";}
45108                 using parent_t = UE_X2AP_ID_Extension;
45109
45110         };
45111         seNB_UE_X2AP_ID_Extension_t& ref_seNB_UE_X2AP_ID_Extension() {return seNB_UE_X2AP_ID_Extension;}
45112         seNB_UE_X2AP_ID_Extension_t const& ref_seNB_UE_X2AP_ID_Extension() const {return seNB_UE_X2AP_ID_Extension;}
45113         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>
45114         {
45115                 static constexpr const char* name() {return "iE_Extensions_t";}
45116                 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSeNB_ItemExtIEs>;
45117                 static constexpr bool optional = true;
45118
45119         };
45120         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45121         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45122         template<typename V> void decode(V& v)
45123         {
45124                 v(source_GlobalSeNB_ID);
45125                 v(seNB_UE_X2AP_ID);
45126                 v(seNB_UE_X2AP_ID_Extension);
45127                 v(iE_Extensions);
45128
45129         };
45130         template<typename V> void encode(V& v) const
45131         {
45132                 v(source_GlobalSeNB_ID);
45133                 v(seNB_UE_X2AP_ID);
45134                 v(seNB_UE_X2AP_ID_Extension);
45135                 v(iE_Extensions);
45136
45137         };
45138         void clear()
45139         {
45140                 source_GlobalSeNB_ID.clear();
45141                 seNB_UE_X2AP_ID.clear();
45142                 seNB_UE_X2AP_ID_Extension.clear();
45143                 iE_Extensions.clear();
45144
45145         };
45146         private:
45147         source_GlobalSeNB_ID_t  source_GlobalSeNB_ID;
45148         seNB_UE_X2AP_ID_t       seNB_UE_X2AP_ID;
45149         seNB_UE_X2AP_ID_Extension_t     seNB_UE_X2AP_ID_Extension;
45150         iE_Extensions_t iE_Extensions;
45151
45152 };
45153 /*
45154 UE-ContextReferenceAtWT-ItemExtIEs      X2AP-PROTOCOL-EXTENSION ::= {
45155         ...
45156 }
45157 */
45158
45159 struct UE_ContextReferenceAtWT_ItemExtIEs
45160 {
45161         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
45162         {
45163                 size_t get_index() const {return type;}
45164                 bool is_unknown() const { return type == 1; }
45165                 void clear() {type = 0;}
45166                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
45167                 template<typename V>  bool decode(V& v)
45168                 {
45169                         clear();
45170                         if(!v(ref_nested())) return false;
45171                         { type = 1; return true;}
45172                         return false;
45173
45174                 }
45175                 template<typename V> bool encode(V& v) const
45176                 {
45177                         return v(ref_nested());
45178
45179                 }
45180                 protected:
45181                 template<typename V>  bool decode(size_t index, V& v)
45182                 {
45183                         clear();
45184                         switch(index)
45185                         {
45186                         case 1: type = 1; return v(ref_nested());
45187                         ref_nested().clear();
45188                         }
45189                         return false;
45190
45191                 }
45192                 template<typename V> bool encode(size_t index, V& v) const
45193                 {
45194                         if(index != type) {return false;} return v(ref_nested());
45195
45196                 }
45197                 private:
45198                 size_t type {0};
45199
45200         };
45201         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
45202         {
45203                 size_t get_index() const {return type;}
45204                 bool is_unknown() const { return type == 1; }
45205                 void clear() {type = 0;}
45206                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
45207                 template<typename V>  bool decode(V& v)
45208                 {
45209                         clear();
45210                         if(!v(ref_nested())) return false;
45211                         { type = 1; return true;}
45212                         return false;
45213
45214                 }
45215                 template<typename V> bool encode(V& v) const
45216                 {
45217                         return v(ref_nested());
45218
45219                 }
45220                 protected:
45221                 template<typename V>  bool decode(size_t index, V& v)
45222                 {
45223                         clear();
45224                         switch(index)
45225                         {
45226                         case 1: type = 1; return v(ref_nested());
45227                         ref_nested().clear();
45228                         }
45229                         return false;
45230
45231                 }
45232                 template<typename V> bool encode(size_t index, V& v) const
45233                 {
45234                         if(index != type) {return false;} return v(ref_nested());
45235
45236                 }
45237                 private:
45238                 size_t type {0};
45239
45240         };
45241         struct Extension_t : asn::typefield<true>
45242         {
45243                 ~Extension_t()  {clear();}
45244                 size_t get_index() const {return type;}
45245                 bool is_unknown() const { return type == 1; }
45246                 void clear()
45247                 {
45248                         type = 0; ref_nested().clear();
45249                 }
45250                 template<typename V> static inline void enumerate(V& v)
45251                 {
45252
45253                 }
45254                 protected:
45255                 template<typename V> bool decode(size_t index, V& v)
45256                 {
45257                         clear();
45258                         switch(index)
45259                         {
45260                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45261                         }
45262                         return false;
45263
45264                 }
45265                 template<typename V> bool encode(size_t index, V& v) const
45266                 {
45267                         if(index != type) return false;
45268                         return false;
45269
45270                 }
45271                 private:
45272                 size_t type {0};
45273
45274         };
45275         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45276         {
45277                 size_t get_index() const {return type;}
45278                 bool is_unknown() const { return type == 1; }
45279                 void clear() {type = 0;}
45280                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45281                 template<typename V>  bool decode(V& v)
45282                 {
45283                         clear();
45284                         if(!v(ref_nested())) return false;
45285                         { type = 1; return true;}
45286                         return false;
45287
45288                 }
45289                 template<typename V> bool encode(V& v) const
45290                 {
45291                         return v(ref_nested());
45292
45293                 }
45294                 protected:
45295                 template<typename V>  bool decode(size_t index, V& v)
45296                 {
45297                         clear();
45298                         switch(index)
45299                         {
45300                         case 1: type = 1; return v(ref_nested());
45301                         ref_nested().clear();
45302                         }
45303                         return false;
45304
45305                 }
45306                 template<typename V> bool encode(size_t index, V& v) const
45307                 {
45308                         if(index != type) {return false;} return v(ref_nested());
45309
45310                 }
45311                 private:
45312                 size_t type {0};
45313
45314         };
45315
45316 };
45317 /*
45318 UE-ContextReferenceAtWT ::= SEQUENCE {
45319         wTID                                    WTID,
45320         wT-UE-XwAP-ID                   WT-UE-XwAP-ID,
45321         iE-Extensions                   ProtocolExtensionContainer { {UE-ContextReferenceAtWT-ItemExtIEs} } OPTIONAL,
45322         ...
45323 }
45324 */
45325
45326 struct UE_ContextReferenceAtWT : asn::sequence<3, 0, true, 1>
45327 {
45328         static constexpr const char* name() {return "UE-ContextReferenceAtWT";}
45329         using parent_t = asn::sequence<3, 0, true, 1>;
45330         struct wTID_t : WTID
45331         {
45332                 static constexpr const char* name() {return "wTID_t";}
45333                 using parent_t = WTID;
45334
45335         };
45336         wTID_t& ref_wTID() {return wTID;}
45337         wTID_t const& ref_wTID() const {return wTID;}
45338         struct wT_UE_XwAP_ID_t : WT_UE_XwAP_ID
45339         {
45340                 static constexpr const char* name() {return "wT_UE_XwAP_ID_t";}
45341                 using parent_t = WT_UE_XwAP_ID;
45342
45343         };
45344         wT_UE_XwAP_ID_t& ref_wT_UE_XwAP_ID() {return wT_UE_XwAP_ID;}
45345         wT_UE_XwAP_ID_t const& ref_wT_UE_XwAP_ID() const {return wT_UE_XwAP_ID;}
45346         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>
45347         {
45348                 static constexpr const char* name() {return "iE_Extensions_t";}
45349                 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtWT_ItemExtIEs>;
45350                 static constexpr bool optional = true;
45351
45352         };
45353         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45354         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45355         template<typename V> void decode(V& v)
45356         {
45357                 v(wTID);
45358                 v(wT_UE_XwAP_ID);
45359                 v(iE_Extensions);
45360
45361         };
45362         template<typename V> void encode(V& v) const
45363         {
45364                 v(wTID);
45365                 v(wT_UE_XwAP_ID);
45366                 v(iE_Extensions);
45367
45368         };
45369         void clear()
45370         {
45371                 wTID.clear();
45372                 wT_UE_XwAP_ID.clear();
45373                 iE_Extensions.clear();
45374
45375         };
45376         private:
45377         wTID_t  wTID;
45378         wT_UE_XwAP_ID_t wT_UE_XwAP_ID;
45379         iE_Extensions_t iE_Extensions;
45380
45381 };
45382 /*
45383 UE-ContextReferenceAtSgNB-ItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
45384         ...
45385 }
45386 */
45387
45388 struct UE_ContextReferenceAtSgNB_ItemExtIEs
45389 {
45390         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
45391         {
45392                 size_t get_index() const {return type;}
45393                 bool is_unknown() const { return type == 1; }
45394                 void clear() {type = 0;}
45395                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
45396                 template<typename V>  bool decode(V& v)
45397                 {
45398                         clear();
45399                         if(!v(ref_nested())) return false;
45400                         { type = 1; return true;}
45401                         return false;
45402
45403                 }
45404                 template<typename V> bool encode(V& v) const
45405                 {
45406                         return v(ref_nested());
45407
45408                 }
45409                 protected:
45410                 template<typename V>  bool decode(size_t index, V& v)
45411                 {
45412                         clear();
45413                         switch(index)
45414                         {
45415                         case 1: type = 1; return v(ref_nested());
45416                         ref_nested().clear();
45417                         }
45418                         return false;
45419
45420                 }
45421                 template<typename V> bool encode(size_t index, V& v) const
45422                 {
45423                         if(index != type) {return false;} return v(ref_nested());
45424
45425                 }
45426                 private:
45427                 size_t type {0};
45428
45429         };
45430         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
45431         {
45432                 size_t get_index() const {return type;}
45433                 bool is_unknown() const { return type == 1; }
45434                 void clear() {type = 0;}
45435                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
45436                 template<typename V>  bool decode(V& v)
45437                 {
45438                         clear();
45439                         if(!v(ref_nested())) return false;
45440                         { type = 1; return true;}
45441                         return false;
45442
45443                 }
45444                 template<typename V> bool encode(V& v) const
45445                 {
45446                         return v(ref_nested());
45447
45448                 }
45449                 protected:
45450                 template<typename V>  bool decode(size_t index, V& v)
45451                 {
45452                         clear();
45453                         switch(index)
45454                         {
45455                         case 1: type = 1; return v(ref_nested());
45456                         ref_nested().clear();
45457                         }
45458                         return false;
45459
45460                 }
45461                 template<typename V> bool encode(size_t index, V& v) const
45462                 {
45463                         if(index != type) {return false;} return v(ref_nested());
45464
45465                 }
45466                 private:
45467                 size_t type {0};
45468
45469         };
45470         struct Extension_t : asn::typefield<true>
45471         {
45472                 ~Extension_t()  {clear();}
45473                 size_t get_index() const {return type;}
45474                 bool is_unknown() const { return type == 1; }
45475                 void clear()
45476                 {
45477                         type = 0; ref_nested().clear();
45478                 }
45479                 template<typename V> static inline void enumerate(V& v)
45480                 {
45481
45482                 }
45483                 protected:
45484                 template<typename V> bool decode(size_t index, V& v)
45485                 {
45486                         clear();
45487                         switch(index)
45488                         {
45489                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
45490                         }
45491                         return false;
45492
45493                 }
45494                 template<typename V> bool encode(size_t index, V& v) const
45495                 {
45496                         if(index != type) return false;
45497                         return false;
45498
45499                 }
45500                 private:
45501                 size_t type {0};
45502
45503         };
45504         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
45505         {
45506                 size_t get_index() const {return type;}
45507                 bool is_unknown() const { return type == 1; }
45508                 void clear() {type = 0;}
45509                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
45510                 template<typename V>  bool decode(V& v)
45511                 {
45512                         clear();
45513                         if(!v(ref_nested())) return false;
45514                         { type = 1; return true;}
45515                         return false;
45516
45517                 }
45518                 template<typename V> bool encode(V& v) const
45519                 {
45520                         return v(ref_nested());
45521
45522                 }
45523                 protected:
45524                 template<typename V>  bool decode(size_t index, V& v)
45525                 {
45526                         clear();
45527                         switch(index)
45528                         {
45529                         case 1: type = 1; return v(ref_nested());
45530                         ref_nested().clear();
45531                         }
45532                         return false;
45533
45534                 }
45535                 template<typename V> bool encode(size_t index, V& v) const
45536                 {
45537                         if(index != type) {return false;} return v(ref_nested());
45538
45539                 }
45540                 private:
45541                 size_t type {0};
45542
45543         };
45544
45545 };
45546 /*
45547 UE-ContextReferenceAtSgNB ::= SEQUENCE {
45548         source-GlobalSgNB-ID                    GlobalGNB-ID,
45549         sgNB-UE-X2AP-ID                         SgNB-UE-X2AP-ID,
45550         iE-Extensions                           ProtocolExtensionContainer { {UE-ContextReferenceAtSgNB-ItemExtIEs} } OPTIONAL,
45551         ...
45552 }
45553 */
45554
45555 struct UE_ContextReferenceAtSgNB : asn::sequence<3, 0, true, 1>
45556 {
45557         static constexpr const char* name() {return "UE-ContextReferenceAtSgNB";}
45558         using parent_t = asn::sequence<3, 0, true, 1>;
45559         struct source_GlobalSgNB_ID_t : GlobalGNB_ID
45560         {
45561                 static constexpr const char* name() {return "source_GlobalSgNB_ID_t";}
45562                 using parent_t = GlobalGNB_ID;
45563
45564         };
45565         source_GlobalSgNB_ID_t& ref_source_GlobalSgNB_ID() {return source_GlobalSgNB_ID;}
45566         source_GlobalSgNB_ID_t const& ref_source_GlobalSgNB_ID() const {return source_GlobalSgNB_ID;}
45567         struct sgNB_UE_X2AP_ID_t : SgNB_UE_X2AP_ID
45568         {
45569                 static constexpr const char* name() {return "sgNB_UE_X2AP_ID_t";}
45570                 using parent_t = SgNB_UE_X2AP_ID;
45571
45572         };
45573         sgNB_UE_X2AP_ID_t& ref_sgNB_UE_X2AP_ID() {return sgNB_UE_X2AP_ID;}
45574         sgNB_UE_X2AP_ID_t const& ref_sgNB_UE_X2AP_ID() const {return sgNB_UE_X2AP_ID;}
45575         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>
45576         {
45577                 static constexpr const char* name() {return "iE_Extensions_t";}
45578                 using parent_t = ProtocolExtensionContainer<UE_ContextReferenceAtSgNB_ItemExtIEs>;
45579                 static constexpr bool optional = true;
45580
45581         };
45582         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
45583         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
45584         template<typename V> void decode(V& v)
45585         {
45586                 v(source_GlobalSgNB_ID);
45587                 v(sgNB_UE_X2AP_ID);
45588                 v(iE_Extensions);
45589
45590         };
45591         template<typename V> void encode(V& v) const
45592         {
45593                 v(source_GlobalSgNB_ID);
45594                 v(sgNB_UE_X2AP_ID);
45595                 v(iE_Extensions);
45596
45597         };
45598         void clear()
45599         {
45600                 source_GlobalSgNB_ID.clear();
45601                 sgNB_UE_X2AP_ID.clear();
45602                 iE_Extensions.clear();
45603
45604         };
45605         private:
45606         source_GlobalSgNB_ID_t  source_GlobalSgNB_ID;
45607         sgNB_UE_X2AP_ID_t       sgNB_UE_X2AP_ID;
45608         iE_Extensions_t iE_Extensions;
45609
45610 };
45611 /*
45612 HandoverRequest-IEs X2AP-PROTOCOL-IES ::= {
45613         { ID id-Old-eNB-UE-X2AP-ID                                      CRITICALITY reject      TYPE UE-X2AP-ID                                                         PRESENCE mandatory}|
45614         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                                                      PRESENCE mandatory}|
45615         { ID id-TargetCell-ID                                           CRITICALITY reject      TYPE ECGI                                                                       PRESENCE mandatory}|
45616         { ID id-GUMMEI-ID                                                       CRITICALITY reject      TYPE GUMMEI                                                                     PRESENCE mandatory}|
45617         { ID id-UE-ContextInformation                           CRITICALITY reject      TYPE UE-ContextInformation                                      PRESENCE mandatory}|
45618         { ID id-UE-HistoryInformation                           CRITICALITY ignore      TYPE UE-HistoryInformation                                      PRESENCE mandatory}|
45619         { ID id-TraceActivation                                         CRITICALITY ignore      TYPE TraceActivation                                            PRESENCE optional}|
45620         { ID id-SRVCCOperationPossible                          CRITICALITY ignore      TYPE SRVCCOperationPossible                                     PRESENCE optional}|
45621         { ID id-CSGMembershipStatus                                     CRITICALITY reject      TYPE CSGMembershipStatus                                        PRESENCE optional}|
45622         { ID id-MobilityInformation                                     CRITICALITY ignore      TYPE MobilityInformation                                        PRESENCE optional}|
45623         { ID id-Masked-IMEISV                                           CRITICALITY ignore      TYPE Masked-IMEISV                                                      PRESENCE optional}|
45624         { ID id-UE-HistoryInformationFromTheUE          CRITICALITY ignore      TYPE UE-HistoryInformationFromTheUE             PRESENCE optional}|
45625         { ID id-ExpectedUEBehaviour                                     CRITICALITY ignore      TYPE ExpectedUEBehaviour                                        PRESENCE optional}|
45626         { ID id-ProSeAuthorized                                         CRITICALITY ignore      TYPE ProSeAuthorized                                            PRESENCE optional}|
45627         { ID id-UE-ContextReferenceAtSeNB                       CRITICALITY ignore      TYPE UE-ContextReferenceAtSeNB                  PRESENCE optional}|
45628         { ID id-Old-eNB-UE-X2AP-ID-Extension            CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                       PRESENCE optional}|
45629         { ID id-V2XServicesAuthorized                           CRITICALITY ignore      TYPE V2XServicesAuthorized                                      PRESENCE optional}|
45630         { ID id-UE-ContextReferenceAtWT                         CRITICALITY ignore      TYPE UE-ContextReferenceAtWT                            PRESENCE optional}|
45631         { ID id-NRUESecurityCapabilities                                CRITICALITY ignore      TYPE NRUESecurityCapabilities                           PRESENCE optional}|
45632         { ID id-UE-ContextReferenceAtSgNB                       CRITICALITY ignore      TYPE UE-ContextReferenceAtSgNB                  PRESENCE optional}|
45633         { ID id-AerialUEsubscriptionInformation         CRITICALITY ignore      TYPE AerialUEsubscriptionInformation    PRESENCE optional}|
45634         { ID id-Subscription-Based-UE-DifferentiationInfo               CRITICALITY ignore      TYPE Subscription-Based-UE-DifferentiationInfo                          PRESENCE optional},
45635         ...
45636 }
45637 */
45638
45639 struct HandoverRequest_IEs
45640 {
45641         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
45642         {
45643                 size_t get_index() const {return type;}
45644                 bool is_unknown() const { return type == 23; }
45645                 void clear() {type = 0;}
45646                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
45647                 void select_id_Cause() { set(id_Cause); type=2;}
45648                 void select_id_TargetCell_ID() { set(id_TargetCell_ID); type=3;}
45649                 void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=4;}
45650                 void select_id_UE_ContextInformation() { set(id_UE_ContextInformation); type=5;}
45651                 void select_id_UE_HistoryInformation() { set(id_UE_HistoryInformation); type=6;}
45652                 void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
45653                 void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
45654                 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=9;}
45655                 void select_id_MobilityInformation() { set(id_MobilityInformation); type=10;}
45656                 void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=11;}
45657                 void select_id_UE_HistoryInformationFromTheUE() { set(id_UE_HistoryInformationFromTheUE); type=12;}
45658                 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=13;}
45659                 void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=14;}
45660                 void select_id_UE_ContextReferenceAtSeNB() { set(id_UE_ContextReferenceAtSeNB); type=15;}
45661                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=16;}
45662                 void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=17;}
45663                 void select_id_UE_ContextReferenceAtWT() { set(id_UE_ContextReferenceAtWT); type=18;}
45664                 void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=19;}
45665                 void select_id_UE_ContextReferenceAtSgNB() { set(id_UE_ContextReferenceAtSgNB); type=20;}
45666                 void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=21;}
45667                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=22;}
45668                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
45669                 template<typename V>  bool decode(V& v)
45670                 {
45671                         clear();
45672                         if(!v(ref_nested())) return false;
45673                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
45674                         else if(equal(id_Cause)) { type = 2; return true; }
45675                         else if(equal(id_TargetCell_ID)) { type = 3; return true; }
45676                         else if(equal(id_GUMMEI_ID)) { type = 4; return true; }
45677                         else if(equal(id_UE_ContextInformation)) { type = 5; return true; }
45678                         else if(equal(id_UE_HistoryInformation)) { type = 6; return true; }
45679                         else if(equal(id_TraceActivation)) { type = 7; return true; }
45680                         else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
45681                         else if(equal(id_CSGMembershipStatus)) { type = 9; return true; }
45682                         else if(equal(id_MobilityInformation)) { type = 10; return true; }
45683                         else if(equal(id_Masked_IMEISV)) { type = 11; return true; }
45684                         else if(equal(id_UE_HistoryInformationFromTheUE)) { type = 12; return true; }
45685                         else if(equal(id_ExpectedUEBehaviour)) { type = 13; return true; }
45686                         else if(equal(id_ProSeAuthorized)) { type = 14; return true; }
45687                         else if(equal(id_UE_ContextReferenceAtSeNB)) { type = 15; return true; }
45688                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 16; return true; }
45689                         else if(equal(id_V2XServicesAuthorized)) { type = 17; return true; }
45690                         else if(equal(id_UE_ContextReferenceAtWT)) { type = 18; return true; }
45691                         else if(equal(id_NRUESecurityCapabilities)) { type = 19; return true; }
45692                         else if(equal(id_UE_ContextReferenceAtSgNB)) { type = 20; return true; }
45693                         else if(equal(id_AerialUEsubscriptionInformation)) { type = 21; return true; }
45694                         else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 22; return true; }
45695                         else { type = 23; return true;}
45696                         return false;
45697
45698                 }
45699                 template<typename V> bool encode(V& v) const
45700                 {
45701                         return v(ref_nested());
45702
45703                 }
45704                 protected:
45705                 template<typename V>  bool decode(size_t index, V& v)
45706                 {
45707                         clear();
45708                         switch(index)
45709                         {
45710                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
45711                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Cause);} return false;
45712                         case 3: type = 3; if(v(ref_nested())) { return equal(id_TargetCell_ID);} return false;
45713                         case 4: type = 4; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
45714                         case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextInformation);} return false;
45715                         case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_HistoryInformation);} return false;
45716                         case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
45717                         case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
45718                         case 9: type = 9; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
45719                         case 10: type = 10; if(v(ref_nested())) { return equal(id_MobilityInformation);} return false;
45720                         case 11: type = 11; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
45721                         case 12: type = 12; if(v(ref_nested())) { return equal(id_UE_HistoryInformationFromTheUE);} return false;
45722                         case 13: type = 13; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
45723                         case 14: type = 14; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
45724                         case 15: type = 15; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSeNB);} return false;
45725                         case 16: type = 16; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
45726                         case 17: type = 17; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
45727                         case 18: type = 18; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtWT);} return false;
45728                         case 19: type = 19; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
45729                         case 20: type = 20; if(v(ref_nested())) { return equal(id_UE_ContextReferenceAtSgNB);} return false;
45730                         case 21: type = 21; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
45731                         case 22: type = 22; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
45732                         case 23: type = 23; return v(ref_nested());
45733                         ref_nested().clear();
45734                         }
45735                         return false;
45736
45737                 }
45738                 template<typename V> bool encode(size_t index, V& v) const
45739                 {
45740                         if(index != type) {return false;} return v(ref_nested());
45741
45742                 }
45743                 private:
45744                 size_t type {0};
45745
45746         };
45747         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
45748         {
45749                 size_t get_index() const {return type;}
45750                 bool is_unknown() const { return type == 23; }
45751                 void clear() {type = 0;}
45752                 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
45753                 void select_id_Cause() { set(ignore); type=2;}
45754                 void select_id_TargetCell_ID() { set(reject); type=3;}
45755                 void select_id_GUMMEI_ID() { set(reject); type=4;}
45756                 void select_id_UE_ContextInformation() { set(reject); type=5;}
45757                 void select_id_UE_HistoryInformation() { set(ignore); type=6;}
45758                 void select_id_TraceActivation() { set(ignore); type=7;}
45759                 void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
45760                 void select_id_CSGMembershipStatus() { set(reject); type=9;}
45761                 void select_id_MobilityInformation() { set(ignore); type=10;}
45762                 void select_id_Masked_IMEISV() { set(ignore); type=11;}
45763                 void select_id_UE_HistoryInformationFromTheUE() { set(ignore); type=12;}
45764                 void select_id_ExpectedUEBehaviour() { set(ignore); type=13;}
45765                 void select_id_ProSeAuthorized() { set(ignore); type=14;}
45766                 void select_id_UE_ContextReferenceAtSeNB() { set(ignore); type=15;}
45767                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=16;}
45768                 void select_id_V2XServicesAuthorized() { set(ignore); type=17;}
45769                 void select_id_UE_ContextReferenceAtWT() { set(ignore); type=18;}
45770                 void select_id_NRUESecurityCapabilities() { set(ignore); type=19;}
45771                 void select_id_UE_ContextReferenceAtSgNB() { set(ignore); type=20;}
45772                 void select_id_AerialUEsubscriptionInformation() { set(ignore); type=21;}
45773                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=22;}
45774                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
45775                 template<typename V>  bool decode(V& v)
45776                 {
45777                         clear();
45778                         if(!v(ref_nested())) return false;
45779                         if(equal(reject)) { type = 1; return true; }
45780                         else if(equal(ignore)) { type = 2; return true; }
45781                         else if(equal(reject)) { type = 3; return true; }
45782                         else if(equal(reject)) { type = 4; return true; }
45783                         else if(equal(reject)) { type = 5; return true; }
45784                         else if(equal(ignore)) { type = 6; return true; }
45785                         else if(equal(ignore)) { type = 7; return true; }
45786                         else if(equal(ignore)) { type = 8; return true; }
45787                         else if(equal(reject)) { type = 9; return true; }
45788                         else if(equal(ignore)) { type = 10; return true; }
45789                         else if(equal(ignore)) { type = 11; return true; }
45790                         else if(equal(ignore)) { type = 12; return true; }
45791                         else if(equal(ignore)) { type = 13; return true; }
45792                         else if(equal(ignore)) { type = 14; return true; }
45793                         else if(equal(ignore)) { type = 15; return true; }
45794                         else if(equal(reject)) { type = 16; return true; }
45795                         else if(equal(ignore)) { type = 17; return true; }
45796                         else if(equal(ignore)) { type = 18; return true; }
45797                         else if(equal(ignore)) { type = 19; return true; }
45798                         else if(equal(ignore)) { type = 20; return true; }
45799                         else if(equal(ignore)) { type = 21; return true; }
45800                         else if(equal(ignore)) { type = 22; return true; }
45801                         else { type = 23; return true;}
45802                         return false;
45803
45804                 }
45805                 template<typename V> bool encode(V& v) const
45806                 {
45807                         return v(ref_nested());
45808
45809                 }
45810                 protected:
45811                 template<typename V>  bool decode(size_t index, V& v)
45812                 {
45813                         clear();
45814                         switch(index)
45815                         {
45816                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
45817                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
45818                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
45819                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
45820                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
45821                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
45822                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
45823                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
45824                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
45825                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
45826                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
45827                         case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
45828                         case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
45829                         case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
45830                         case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
45831                         case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
45832                         case 17: type = 17; if(v(ref_nested())) { return equal(ignore);} return false;
45833                         case 18: type = 18; if(v(ref_nested())) { return equal(ignore);} return false;
45834                         case 19: type = 19; if(v(ref_nested())) { return equal(ignore);} return false;
45835                         case 20: type = 20; if(v(ref_nested())) { return equal(ignore);} return false;
45836                         case 21: type = 21; if(v(ref_nested())) { return equal(ignore);} return false;
45837                         case 22: type = 22; if(v(ref_nested())) { return equal(ignore);} return false;
45838                         case 23: type = 23; return v(ref_nested());
45839                         ref_nested().clear();
45840                         }
45841                         return false;
45842
45843                 }
45844                 template<typename V> bool encode(size_t index, V& v) const
45845                 {
45846                         if(index != type) {return false;} return v(ref_nested());
45847
45848                 }
45849                 private:
45850                 size_t type {0};
45851
45852         };
45853         struct Value_t : asn::typefield<true>
45854         {
45855                 ~Value_t()      {clear();}
45856                 size_t get_index() const {return type;}
45857                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
45858                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
45859                 Cause& select_id_Cause() { return set<Cause>(2); }
45860                 Cause const* get_id_Cause() const { return get<Cause>(2); }
45861                 ECGI& select_id_TargetCell_ID() { return set<ECGI>(3); }
45862                 ECGI const* get_id_TargetCell_ID() const { return get<ECGI>(3); }
45863                 GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(4); }
45864                 GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(4); }
45865                 UE_ContextInformation& select_id_UE_ContextInformation() { return set<UE_ContextInformation>(5); }
45866                 UE_ContextInformation const* get_id_UE_ContextInformation() const { return get<UE_ContextInformation>(5); }
45867                 UE_HistoryInformation& select_id_UE_HistoryInformation() { return set<UE_HistoryInformation>(6); }
45868                 UE_HistoryInformation const* get_id_UE_HistoryInformation() const { return get<UE_HistoryInformation>(6); }
45869                 TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
45870                 TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
45871                 SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
45872                 SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
45873                 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(9); }
45874                 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(9); }
45875                 MobilityInformation& select_id_MobilityInformation() { return set<MobilityInformation>(10); }
45876                 MobilityInformation const* get_id_MobilityInformation() const { return get<MobilityInformation>(10); }
45877                 Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(11); }
45878                 Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(11); }
45879                 UE_HistoryInformationFromTheUE& select_id_UE_HistoryInformationFromTheUE() { return set<UE_HistoryInformationFromTheUE>(12); }
45880                 UE_HistoryInformationFromTheUE const* get_id_UE_HistoryInformationFromTheUE() const { return get<UE_HistoryInformationFromTheUE>(12); }
45881                 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(13); }
45882                 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(13); }
45883                 ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(14); }
45884                 ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(14); }
45885                 UE_ContextReferenceAtSeNB& select_id_UE_ContextReferenceAtSeNB() { return set<UE_ContextReferenceAtSeNB>(15); }
45886                 UE_ContextReferenceAtSeNB const* get_id_UE_ContextReferenceAtSeNB() const { return get<UE_ContextReferenceAtSeNB>(15); }
45887                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(16); }
45888                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(16); }
45889                 V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(17); }
45890                 V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(17); }
45891                 UE_ContextReferenceAtWT& select_id_UE_ContextReferenceAtWT() { return set<UE_ContextReferenceAtWT>(18); }
45892                 UE_ContextReferenceAtWT const* get_id_UE_ContextReferenceAtWT() const { return get<UE_ContextReferenceAtWT>(18); }
45893                 NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(19); }
45894                 NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(19); }
45895                 UE_ContextReferenceAtSgNB& select_id_UE_ContextReferenceAtSgNB() { return set<UE_ContextReferenceAtSgNB>(20); }
45896                 UE_ContextReferenceAtSgNB const* get_id_UE_ContextReferenceAtSgNB() const { return get<UE_ContextReferenceAtSgNB>(20); }
45897                 AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(21); }
45898                 AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(21); }
45899                 Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(22); }
45900                 Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(22); }
45901                 bool is_unknown() const { return type == 23; }
45902                 void clear()
45903                 {
45904                         switch(type)
45905                         {
45906                         case 1: var.destroy<UE_X2AP_ID>(); break;
45907                         case 2: var.destroy<Cause>(); break;
45908                         case 3: var.destroy<ECGI>(); break;
45909                         case 4: var.destroy<GUMMEI>(); break;
45910                         case 5: var.destroy<UE_ContextInformation>(); break;
45911                         case 6: var.destroy<UE_HistoryInformation>(); break;
45912                         case 7: var.destroy<TraceActivation>(); break;
45913                         case 8: var.destroy<SRVCCOperationPossible>(); break;
45914                         case 9: var.destroy<CSGMembershipStatus>(); break;
45915                         case 10: var.destroy<MobilityInformation>(); break;
45916                         case 11: var.destroy<Masked_IMEISV>(); break;
45917                         case 12: var.destroy<UE_HistoryInformationFromTheUE>(); break;
45918                         case 13: var.destroy<ExpectedUEBehaviour>(); break;
45919                         case 14: var.destroy<ProSeAuthorized>(); break;
45920                         case 15: var.destroy<UE_ContextReferenceAtSeNB>(); break;
45921                         case 16: var.destroy<UE_X2AP_ID_Extension>(); break;
45922                         case 17: var.destroy<V2XServicesAuthorized>(); break;
45923                         case 18: var.destroy<UE_ContextReferenceAtWT>(); break;
45924                         case 19: var.destroy<NRUESecurityCapabilities>(); break;
45925                         case 20: var.destroy<UE_ContextReferenceAtSgNB>(); break;
45926                         case 21: var.destroy<AerialUEsubscriptionInformation>(); break;
45927                         case 22: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
45928                         }
45929                         type = 0; ref_nested().clear();
45930                 }
45931                 template<typename V> static inline void enumerate(V& v)
45932                 {
45933                         v.template operator()<UE_X2AP_ID>(1);
45934                         v.template operator()<Cause>(2);
45935                         v.template operator()<ECGI>(3);
45936                         v.template operator()<GUMMEI>(4);
45937                         v.template operator()<UE_ContextInformation>(5);
45938                         v.template operator()<UE_HistoryInformation>(6);
45939                         v.template operator()<TraceActivation>(7);
45940                         v.template operator()<SRVCCOperationPossible>(8);
45941                         v.template operator()<CSGMembershipStatus>(9);
45942                         v.template operator()<MobilityInformation>(10);
45943                         v.template operator()<Masked_IMEISV>(11);
45944                         v.template operator()<UE_HistoryInformationFromTheUE>(12);
45945                         v.template operator()<ExpectedUEBehaviour>(13);
45946                         v.template operator()<ProSeAuthorized>(14);
45947                         v.template operator()<UE_ContextReferenceAtSeNB>(15);
45948                         v.template operator()<UE_X2AP_ID_Extension>(16);
45949                         v.template operator()<V2XServicesAuthorized>(17);
45950                         v.template operator()<UE_ContextReferenceAtWT>(18);
45951                         v.template operator()<NRUESecurityCapabilities>(19);
45952                         v.template operator()<UE_ContextReferenceAtSgNB>(20);
45953                         v.template operator()<AerialUEsubscriptionInformation>(21);
45954                         v.template operator()<Subscription_Based_UE_DifferentiationInfo>(22);
45955
45956                 }
45957                 protected:
45958                 template<typename V> bool decode(size_t index, V& v)
45959                 {
45960                         clear();
45961                         switch(index)
45962                         {
45963                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
45964                         case 2: v(select_id_Cause()); return true;
45965                         case 3: v(select_id_TargetCell_ID()); return true;
45966                         case 4: v(select_id_GUMMEI_ID()); return true;
45967                         case 5: v(select_id_UE_ContextInformation()); return true;
45968                         case 6: v(select_id_UE_HistoryInformation()); return true;
45969                         case 7: v(select_id_TraceActivation()); return true;
45970                         case 8: v(select_id_SRVCCOperationPossible()); return true;
45971                         case 9: v(select_id_CSGMembershipStatus()); return true;
45972                         case 10: v(select_id_MobilityInformation()); return true;
45973                         case 11: v(select_id_Masked_IMEISV()); return true;
45974                         case 12: v(select_id_UE_HistoryInformationFromTheUE()); return true;
45975                         case 13: v(select_id_ExpectedUEBehaviour()); return true;
45976                         case 14: v(select_id_ProSeAuthorized()); return true;
45977                         case 15: v(select_id_UE_ContextReferenceAtSeNB()); return true;
45978                         case 16: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
45979                         case 17: v(select_id_V2XServicesAuthorized()); return true;
45980                         case 18: v(select_id_UE_ContextReferenceAtWT()); return true;
45981                         case 19: v(select_id_NRUESecurityCapabilities()); return true;
45982                         case 20: v(select_id_UE_ContextReferenceAtSgNB()); return true;
45983                         case 21: v(select_id_AerialUEsubscriptionInformation()); return true;
45984                         case 22: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
45985                         case 23: if(type != 23) {clear(); asn::base::set();} type = 23; return true;
45986                         }
45987                         return false;
45988
45989                 }
45990                 template<typename V> bool encode(size_t index, V& v) const
45991                 {
45992                         if(index != type) return false;
45993                         switch(type)
45994                         {
45995                         case 1: v(var.as<UE_X2AP_ID>()); return true;
45996                         case 2: v(var.as<Cause>()); return true;
45997                         case 3: v(var.as<ECGI>()); return true;
45998                         case 4: v(var.as<GUMMEI>()); return true;
45999                         case 5: v(var.as<UE_ContextInformation>()); return true;
46000                         case 6: v(var.as<UE_HistoryInformation>()); return true;
46001                         case 7: v(var.as<TraceActivation>()); return true;
46002                         case 8: v(var.as<SRVCCOperationPossible>()); return true;
46003                         case 9: v(var.as<CSGMembershipStatus>()); return true;
46004                         case 10: v(var.as<MobilityInformation>()); return true;
46005                         case 11: v(var.as<Masked_IMEISV>()); return true;
46006                         case 12: v(var.as<UE_HistoryInformationFromTheUE>()); return true;
46007                         case 13: v(var.as<ExpectedUEBehaviour>()); return true;
46008                         case 14: v(var.as<ProSeAuthorized>()); return true;
46009                         case 15: v(var.as<UE_ContextReferenceAtSeNB>()); return true;
46010                         case 16: v(var.as<UE_X2AP_ID_Extension>()); return true;
46011                         case 17: v(var.as<V2XServicesAuthorized>()); return true;
46012                         case 18: v(var.as<UE_ContextReferenceAtWT>()); return true;
46013                         case 19: v(var.as<NRUESecurityCapabilities>()); return true;
46014                         case 20: v(var.as<UE_ContextReferenceAtSgNB>()); return true;
46015                         case 21: v(var.as<AerialUEsubscriptionInformation>()); return true;
46016                         case 22: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); return true;
46017                         }
46018                         return false;
46019
46020                 }
46021                 private:
46022                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46023                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46024                 union union_type
46025                 {
46026                         char dummy1[sizeof(AerialUEsubscriptionInformation)];
46027                         char dummy2[sizeof(CSGMembershipStatus)];
46028                         char dummy3[sizeof(Cause)];
46029                         char dummy4[sizeof(ECGI)];
46030                         char dummy5[sizeof(ExpectedUEBehaviour)];
46031                         char dummy6[sizeof(GUMMEI)];
46032                         char dummy7[sizeof(Masked_IMEISV)];
46033                         char dummy8[sizeof(MobilityInformation)];
46034                         char dummy9[sizeof(NRUESecurityCapabilities)];
46035                         char dummy10[sizeof(ProSeAuthorized)];
46036                         char dummy11[sizeof(SRVCCOperationPossible)];
46037                         char dummy12[sizeof(Subscription_Based_UE_DifferentiationInfo)];
46038                         char dummy13[sizeof(TraceActivation)];
46039                         char dummy14[sizeof(UE_ContextInformation)];
46040                         char dummy15[sizeof(UE_ContextReferenceAtSeNB)];
46041                         char dummy16[sizeof(UE_ContextReferenceAtSgNB)];
46042                         char dummy17[sizeof(UE_ContextReferenceAtWT)];
46043                         char dummy18[sizeof(UE_HistoryInformation)];
46044                         char dummy19[sizeof(UE_HistoryInformationFromTheUE)];
46045                         char dummy20[sizeof(UE_X2AP_ID)];
46046                         char dummy21[sizeof(UE_X2AP_ID_Extension)];
46047                         char dummy22[sizeof(V2XServicesAuthorized)];
46048
46049                 };
46050                 asn::variant<sizeof(union_type)> var;
46051                 size_t type {0};
46052
46053         };
46054         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46055         {
46056                 size_t get_index() const {return type;}
46057                 bool is_unknown() const { return type == 23; }
46058                 void clear() {type = 0;}
46059                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
46060                 void select_id_Cause() { set(mandatory); type=2;}
46061                 void select_id_TargetCell_ID() { set(mandatory); type=3;}
46062                 void select_id_GUMMEI_ID() { set(mandatory); type=4;}
46063                 void select_id_UE_ContextInformation() { set(mandatory); type=5;}
46064                 void select_id_UE_HistoryInformation() { set(mandatory); type=6;}
46065                 void select_id_TraceActivation() { set(optional); type=7;}
46066                 void select_id_SRVCCOperationPossible() { set(optional); type=8;}
46067                 void select_id_CSGMembershipStatus() { set(optional); type=9;}
46068                 void select_id_MobilityInformation() { set(optional); type=10;}
46069                 void select_id_Masked_IMEISV() { set(optional); type=11;}
46070                 void select_id_UE_HistoryInformationFromTheUE() { set(optional); type=12;}
46071                 void select_id_ExpectedUEBehaviour() { set(optional); type=13;}
46072                 void select_id_ProSeAuthorized() { set(optional); type=14;}
46073                 void select_id_UE_ContextReferenceAtSeNB() { set(optional); type=15;}
46074                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=16;}
46075                 void select_id_V2XServicesAuthorized() { set(optional); type=17;}
46076                 void select_id_UE_ContextReferenceAtWT() { set(optional); type=18;}
46077                 void select_id_NRUESecurityCapabilities() { set(optional); type=19;}
46078                 void select_id_UE_ContextReferenceAtSgNB() { set(optional); type=20;}
46079                 void select_id_AerialUEsubscriptionInformation() { set(optional); type=21;}
46080                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=22;}
46081                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46082                 template<typename V>  bool decode(V& v)
46083                 {
46084                         clear();
46085                         if(!v(ref_nested())) return false;
46086                         if(equal(mandatory)) { type = 1; return true; }
46087                         else if(equal(mandatory)) { type = 2; return true; }
46088                         else if(equal(mandatory)) { type = 3; return true; }
46089                         else if(equal(mandatory)) { type = 4; return true; }
46090                         else if(equal(mandatory)) { type = 5; return true; }
46091                         else if(equal(mandatory)) { type = 6; return true; }
46092                         else if(equal(optional)) { type = 7; return true; }
46093                         else if(equal(optional)) { type = 8; return true; }
46094                         else if(equal(optional)) { type = 9; return true; }
46095                         else if(equal(optional)) { type = 10; return true; }
46096                         else if(equal(optional)) { type = 11; return true; }
46097                         else if(equal(optional)) { type = 12; return true; }
46098                         else if(equal(optional)) { type = 13; return true; }
46099                         else if(equal(optional)) { type = 14; return true; }
46100                         else if(equal(optional)) { type = 15; return true; }
46101                         else if(equal(optional)) { type = 16; return true; }
46102                         else if(equal(optional)) { type = 17; return true; }
46103                         else if(equal(optional)) { type = 18; return true; }
46104                         else if(equal(optional)) { type = 19; return true; }
46105                         else if(equal(optional)) { type = 20; return true; }
46106                         else if(equal(optional)) { type = 21; return true; }
46107                         else if(equal(optional)) { type = 22; return true; }
46108                         else { type = 23; return true;}
46109                         return false;
46110
46111                 }
46112                 template<typename V> bool encode(V& v) const
46113                 {
46114                         return v(ref_nested());
46115
46116                 }
46117                 protected:
46118                 template<typename V>  bool decode(size_t index, V& v)
46119                 {
46120                         clear();
46121                         switch(index)
46122                         {
46123                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46124                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
46125                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
46126                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
46127                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
46128                         case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
46129                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
46130                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
46131                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
46132                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
46133                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
46134                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
46135                         case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
46136                         case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
46137                         case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
46138                         case 16: type = 16; if(v(ref_nested())) { return equal(optional);} return false;
46139                         case 17: type = 17; if(v(ref_nested())) { return equal(optional);} return false;
46140                         case 18: type = 18; if(v(ref_nested())) { return equal(optional);} return false;
46141                         case 19: type = 19; if(v(ref_nested())) { return equal(optional);} return false;
46142                         case 20: type = 20; if(v(ref_nested())) { return equal(optional);} return false;
46143                         case 21: type = 21; if(v(ref_nested())) { return equal(optional);} return false;
46144                         case 22: type = 22; if(v(ref_nested())) { return equal(optional);} return false;
46145                         case 23: type = 23; return v(ref_nested());
46146                         ref_nested().clear();
46147                         }
46148                         return false;
46149
46150                 }
46151                 template<typename V> bool encode(size_t index, V& v) const
46152                 {
46153                         if(index != type) {return false;} return v(ref_nested());
46154
46155                 }
46156                 private:
46157                 size_t type {0};
46158
46159         };
46160
46161 };
46162 /*
46163 HandoverRequest ::= SEQUENCE {
46164         protocolIEs                     ProtocolIE-Container    {{HandoverRequest-IEs}},
46165         ...
46166 }
46167 */
46168
46169 struct HandoverRequest : asn::sequence<1, 0, true, 0>
46170 {
46171         static constexpr const char* name() {return "HandoverRequest";}
46172         using parent_t = asn::sequence<1, 0, true, 0>;
46173         struct protocolIEs_t : ProtocolIE_Container<HandoverRequest_IEs>
46174         {
46175                 static constexpr const char* name() {return "protocolIEs_t";}
46176                 using parent_t = ProtocolIE_Container<HandoverRequest_IEs>;
46177
46178         };
46179         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46180         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46181         template<typename V> void decode(V& v)
46182         {
46183                 v(protocolIEs);
46184
46185         };
46186         template<typename V> void encode(V& v) const
46187         {
46188                 v(protocolIEs);
46189
46190         };
46191         void clear()
46192         {
46193                 protocolIEs.clear();
46194
46195         };
46196         private:
46197         protocolIEs_t   protocolIEs;
46198
46199 };
46200 /*
46201 HandoverRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
46202         { ID id-Old-eNB-UE-X2AP-ID                                                      CRITICALITY ignore      TYPE UE-X2AP-ID         PRESENCE mandatory}|
46203         { ID id-New-eNB-UE-X2AP-ID                                                      CRITICALITY ignore      TYPE UE-X2AP-ID         PRESENCE mandatory}|
46204         { ID id-E-RABs-Admitted-List                                            CRITICALITY ignore      TYPE E-RABs-Admitted-List       PRESENCE mandatory}|
46205         { ID id-E-RABs-NotAdmitted-List                                         CRITICALITY ignore      TYPE E-RAB-List         PRESENCE optional}|
46206         { ID id-TargeteNBtoSource-eNBTransparentContainer       CRITICALITY ignore      TYPE TargeteNBtoSource-eNBTransparentContainer  PRESENCE mandatory}|
46207         { ID id-CriticalityDiagnostics                                          CRITICALITY ignore      TYPE CriticalityDiagnostics     PRESENCE optional}|
46208         { ID id-UE-ContextKeptIndicator                                         CRITICALITY ignore      TYPE UE-ContextKeptIndicator    PRESENCE optional}|
46209         { ID id-SeNB-UE-X2AP-ID-Extension                                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension       PRESENCE optional}|
46210         { ID id-Old-eNB-UE-X2AP-ID-Extension                            CRITICALITY ignore      TYPE UE-X2AP-ID-Extension       PRESENCE optional}|
46211         { ID id-New-eNB-UE-X2AP-ID-Extension                            CRITICALITY reject      TYPE UE-X2AP-ID-Extension       PRESENCE optional}|
46212         { ID id-WT-UE-ContextKeptIndicator                                      CRITICALITY ignore      TYPE UE-ContextKeptIndicator    PRESENCE optional},
46213         ...
46214 }
46215 */
46216
46217 struct HandoverRequestAcknowledge_IEs
46218 {
46219         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
46220         {
46221                 size_t get_index() const {return type;}
46222                 bool is_unknown() const { return type == 12; }
46223                 void clear() {type = 0;}
46224                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
46225                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
46226                 void select_id_E_RABs_Admitted_List() { set(id_E_RABs_Admitted_List); type=3;}
46227                 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
46228                 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(id_TargeteNBtoSource_eNBTransparentContainer); type=5;}
46229                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
46230                 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=7;}
46231                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
46232                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=9;}
46233                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=10;}
46234                 void select_id_WT_UE_ContextKeptIndicator() { set(id_WT_UE_ContextKeptIndicator); type=11;}
46235                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
46236                 template<typename V>  bool decode(V& v)
46237                 {
46238                         clear();
46239                         if(!v(ref_nested())) return false;
46240                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
46241                         else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
46242                         else if(equal(id_E_RABs_Admitted_List)) { type = 3; return true; }
46243                         else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
46244                         else if(equal(id_TargeteNBtoSource_eNBTransparentContainer)) { type = 5; return true; }
46245                         else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
46246                         else if(equal(id_UE_ContextKeptIndicator)) { type = 7; return true; }
46247                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
46248                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
46249                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
46250                         else if(equal(id_WT_UE_ContextKeptIndicator)) { type = 11; return true; }
46251                         else { type = 12; return true;}
46252                         return false;
46253
46254                 }
46255                 template<typename V> bool encode(V& v) const
46256                 {
46257                         return v(ref_nested());
46258
46259                 }
46260                 protected:
46261                 template<typename V>  bool decode(size_t index, V& v)
46262                 {
46263                         clear();
46264                         switch(index)
46265                         {
46266                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
46267                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
46268                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_List);} return false;
46269                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
46270                         case 5: type = 5; if(v(ref_nested())) { return equal(id_TargeteNBtoSource_eNBTransparentContainer);} return false;
46271                         case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
46272                         case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
46273                         case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
46274                         case 9: type = 9; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
46275                         case 10: type = 10; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
46276                         case 11: type = 11; if(v(ref_nested())) { return equal(id_WT_UE_ContextKeptIndicator);} return false;
46277                         case 12: type = 12; return v(ref_nested());
46278                         ref_nested().clear();
46279                         }
46280                         return false;
46281
46282                 }
46283                 template<typename V> bool encode(size_t index, V& v) const
46284                 {
46285                         if(index != type) {return false;} return v(ref_nested());
46286
46287                 }
46288                 private:
46289                 size_t type {0};
46290
46291         };
46292         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
46293         {
46294                 size_t get_index() const {return type;}
46295                 bool is_unknown() const { return type == 12; }
46296                 void clear() {type = 0;}
46297                 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=1;}
46298                 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=2;}
46299                 void select_id_E_RABs_Admitted_List() { set(ignore); type=3;}
46300                 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
46301                 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(ignore); type=5;}
46302                 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
46303                 void select_id_UE_ContextKeptIndicator() { set(ignore); type=7;}
46304                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=8;}
46305                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
46306                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
46307                 void select_id_WT_UE_ContextKeptIndicator() { set(ignore); type=11;}
46308                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
46309                 template<typename V>  bool decode(V& v)
46310                 {
46311                         clear();
46312                         if(!v(ref_nested())) return false;
46313                         if(equal(ignore)) { type = 1; return true; }
46314                         else if(equal(ignore)) { type = 2; return true; }
46315                         else if(equal(ignore)) { type = 3; return true; }
46316                         else if(equal(ignore)) { type = 4; return true; }
46317                         else if(equal(ignore)) { type = 5; return true; }
46318                         else if(equal(ignore)) { type = 6; return true; }
46319                         else if(equal(ignore)) { type = 7; return true; }
46320                         else if(equal(ignore)) { type = 8; return true; }
46321                         else if(equal(ignore)) { type = 9; return true; }
46322                         else if(equal(reject)) { type = 10; return true; }
46323                         else if(equal(ignore)) { type = 11; return true; }
46324                         else { type = 12; return true;}
46325                         return false;
46326
46327                 }
46328                 template<typename V> bool encode(V& v) const
46329                 {
46330                         return v(ref_nested());
46331
46332                 }
46333                 protected:
46334                 template<typename V>  bool decode(size_t index, V& v)
46335                 {
46336                         clear();
46337                         switch(index)
46338                         {
46339                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
46340                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
46341                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
46342                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
46343                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
46344                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
46345                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
46346                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
46347                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
46348                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
46349                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
46350                         case 12: type = 12; return v(ref_nested());
46351                         ref_nested().clear();
46352                         }
46353                         return false;
46354
46355                 }
46356                 template<typename V> bool encode(size_t index, V& v) const
46357                 {
46358                         if(index != type) {return false;} return v(ref_nested());
46359
46360                 }
46361                 private:
46362                 size_t type {0};
46363
46364         };
46365         struct Value_t : asn::typefield<true>
46366         {
46367                 ~Value_t()      {clear();}
46368                 size_t get_index() const {return type;}
46369                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
46370                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
46371                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
46372                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
46373                 E_RABs_Admitted_List& select_id_E_RABs_Admitted_List() { return set<E_RABs_Admitted_List>(3); }
46374                 E_RABs_Admitted_List const* get_id_E_RABs_Admitted_List() const { return get<E_RABs_Admitted_List>(3); }
46375                 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
46376                 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
46377                 TargeteNBtoSource_eNBTransparentContainer& select_id_TargeteNBtoSource_eNBTransparentContainer() { return set<TargeteNBtoSource_eNBTransparentContainer>(5); }
46378                 TargeteNBtoSource_eNBTransparentContainer const* get_id_TargeteNBtoSource_eNBTransparentContainer() const { return get<TargeteNBtoSource_eNBTransparentContainer>(5); }
46379                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
46380                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
46381                 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(7); }
46382                 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(7); }
46383                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
46384                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
46385                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
46386                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
46387                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
46388                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
46389                 UE_ContextKeptIndicator& select_id_WT_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(11); }
46390                 UE_ContextKeptIndicator const* get_id_WT_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(11); }
46391                 bool is_unknown() const { return type == 12; }
46392                 void clear()
46393                 {
46394                         switch(type)
46395                         {
46396                         case 1: var.destroy<UE_X2AP_ID>(); break;
46397                         case 2: var.destroy<UE_X2AP_ID>(); break;
46398                         case 3: var.destroy<E_RABs_Admitted_List>(); break;
46399                         case 4: var.destroy<E_RAB_List>(); break;
46400                         case 5: var.destroy<TargeteNBtoSource_eNBTransparentContainer>(); break;
46401                         case 6: var.destroy<CriticalityDiagnostics>(); break;
46402                         case 7: var.destroy<UE_ContextKeptIndicator>(); break;
46403                         case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
46404                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
46405                         case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
46406                         case 11: var.destroy<UE_ContextKeptIndicator>(); break;
46407                         }
46408                         type = 0; ref_nested().clear();
46409                 }
46410                 template<typename V> static inline void enumerate(V& v)
46411                 {
46412                         v.template operator()<UE_X2AP_ID>(1);
46413                         v.template operator()<UE_X2AP_ID>(2);
46414                         v.template operator()<E_RABs_Admitted_List>(3);
46415                         v.template operator()<E_RAB_List>(4);
46416                         v.template operator()<TargeteNBtoSource_eNBTransparentContainer>(5);
46417                         v.template operator()<CriticalityDiagnostics>(6);
46418                         v.template operator()<UE_ContextKeptIndicator>(7);
46419                         v.template operator()<UE_X2AP_ID_Extension>(8);
46420                         v.template operator()<UE_X2AP_ID_Extension>(9);
46421                         v.template operator()<UE_X2AP_ID_Extension>(10);
46422                         v.template operator()<UE_ContextKeptIndicator>(11);
46423
46424                 }
46425                 protected:
46426                 template<typename V> bool decode(size_t index, V& v)
46427                 {
46428                         clear();
46429                         switch(index)
46430                         {
46431                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
46432                         case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
46433                         case 3: v(select_id_E_RABs_Admitted_List()); return true;
46434                         case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
46435                         case 5: v(select_id_TargeteNBtoSource_eNBTransparentContainer()); return true;
46436                         case 6: v(select_id_CriticalityDiagnostics()); return true;
46437                         case 7: v(select_id_UE_ContextKeptIndicator()); return true;
46438                         case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
46439                         case 9: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
46440                         case 10: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
46441                         case 11: v(select_id_WT_UE_ContextKeptIndicator()); return true;
46442                         case 12: if(type != 12) {clear(); asn::base::set();} type = 12; return true;
46443                         }
46444                         return false;
46445
46446                 }
46447                 template<typename V> bool encode(size_t index, V& v) const
46448                 {
46449                         if(index != type) return false;
46450                         switch(type)
46451                         {
46452                         case 1: v(var.as<UE_X2AP_ID>()); return true;
46453                         case 2: v(var.as<UE_X2AP_ID>()); return true;
46454                         case 3: v(var.as<E_RABs_Admitted_List>()); return true;
46455                         case 4: v(var.as<E_RAB_List>()); return true;
46456                         case 5: v(var.as<TargeteNBtoSource_eNBTransparentContainer>()); return true;
46457                         case 6: v(var.as<CriticalityDiagnostics>()); return true;
46458                         case 7: v(var.as<UE_ContextKeptIndicator>()); return true;
46459                         case 8: v(var.as<UE_X2AP_ID_Extension>()); return true;
46460                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
46461                         case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
46462                         case 11: v(var.as<UE_ContextKeptIndicator>()); return true;
46463                         }
46464                         return false;
46465
46466                 }
46467                 private:
46468                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46469                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46470                 union union_type
46471                 {
46472                         char dummy1[sizeof(CriticalityDiagnostics)];
46473                         char dummy2[sizeof(E_RAB_List)];
46474                         char dummy3[sizeof(E_RABs_Admitted_List)];
46475                         char dummy4[sizeof(TargeteNBtoSource_eNBTransparentContainer)];
46476                         char dummy5[sizeof(UE_ContextKeptIndicator)];
46477                         char dummy6[sizeof(UE_X2AP_ID)];
46478                         char dummy7[sizeof(UE_X2AP_ID_Extension)];
46479
46480                 };
46481                 asn::variant<sizeof(union_type)> var;
46482                 size_t type {0};
46483
46484         };
46485         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46486         {
46487                 size_t get_index() const {return type;}
46488                 bool is_unknown() const { return type == 12; }
46489                 void clear() {type = 0;}
46490                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
46491                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
46492                 void select_id_E_RABs_Admitted_List() { set(mandatory); type=3;}
46493                 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
46494                 void select_id_TargeteNBtoSource_eNBTransparentContainer() { set(mandatory); type=5;}
46495                 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
46496                 void select_id_UE_ContextKeptIndicator() { set(optional); type=7;}
46497                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
46498                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
46499                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
46500                 void select_id_WT_UE_ContextKeptIndicator() { set(optional); type=11;}
46501                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46502                 template<typename V>  bool decode(V& v)
46503                 {
46504                         clear();
46505                         if(!v(ref_nested())) return false;
46506                         if(equal(mandatory)) { type = 1; return true; }
46507                         else if(equal(mandatory)) { type = 2; return true; }
46508                         else if(equal(mandatory)) { type = 3; return true; }
46509                         else if(equal(optional)) { type = 4; return true; }
46510                         else if(equal(mandatory)) { type = 5; return true; }
46511                         else if(equal(optional)) { type = 6; return true; }
46512                         else if(equal(optional)) { type = 7; return true; }
46513                         else if(equal(optional)) { type = 8; return true; }
46514                         else if(equal(optional)) { type = 9; return true; }
46515                         else if(equal(optional)) { type = 10; return true; }
46516                         else if(equal(optional)) { type = 11; return true; }
46517                         else { type = 12; return true;}
46518                         return false;
46519
46520                 }
46521                 template<typename V> bool encode(V& v) const
46522                 {
46523                         return v(ref_nested());
46524
46525                 }
46526                 protected:
46527                 template<typename V>  bool decode(size_t index, V& v)
46528                 {
46529                         clear();
46530                         switch(index)
46531                         {
46532                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46533                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
46534                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
46535                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
46536                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
46537                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
46538                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
46539                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
46540                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
46541                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
46542                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
46543                         case 12: type = 12; return v(ref_nested());
46544                         ref_nested().clear();
46545                         }
46546                         return false;
46547
46548                 }
46549                 template<typename V> bool encode(size_t index, V& v) const
46550                 {
46551                         if(index != type) {return false;} return v(ref_nested());
46552
46553                 }
46554                 private:
46555                 size_t type {0};
46556
46557         };
46558
46559 };
46560 /*
46561 HandoverRequestAcknowledge ::= SEQUENCE {
46562         protocolIEs             ProtocolIE-Container    {{HandoverRequestAcknowledge-IEs}},
46563         ...
46564 }
46565 */
46566
46567 struct HandoverRequestAcknowledge : asn::sequence<1, 0, true, 0>
46568 {
46569         static constexpr const char* name() {return "HandoverRequestAcknowledge";}
46570         using parent_t = asn::sequence<1, 0, true, 0>;
46571         struct protocolIEs_t : ProtocolIE_Container<HandoverRequestAcknowledge_IEs>
46572         {
46573                 static constexpr const char* name() {return "protocolIEs_t";}
46574                 using parent_t = ProtocolIE_Container<HandoverRequestAcknowledge_IEs>;
46575
46576         };
46577         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46578         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46579         template<typename V> void decode(V& v)
46580         {
46581                 v(protocolIEs);
46582
46583         };
46584         template<typename V> void encode(V& v) const
46585         {
46586                 v(protocolIEs);
46587
46588         };
46589         void clear()
46590         {
46591                 protocolIEs.clear();
46592
46593         };
46594         private:
46595         protocolIEs_t   protocolIEs;
46596
46597 };
46598 /*
46599 LoadInformation-IEs X2AP-PROTOCOL-IES ::= {
46600         { ID id-CellInformation                         CRITICALITY ignore      TYPE CellInformation-List               PRESENCE mandatory} ,
46601         ...
46602 }
46603 */
46604
46605 struct LoadInformation_IEs
46606 {
46607         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
46608         {
46609                 size_t get_index() const {return type;}
46610                 bool is_unknown() const { return type == 2; }
46611                 void clear() {type = 0;}
46612                 void select_id_CellInformation() { set(id_CellInformation); type=1;}
46613                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
46614                 template<typename V>  bool decode(V& v)
46615                 {
46616                         clear();
46617                         if(!v(ref_nested())) return false;
46618                         if(equal(id_CellInformation)) { type = 1; return true; }
46619                         else { type = 2; return true;}
46620                         return false;
46621
46622                 }
46623                 template<typename V> bool encode(V& v) const
46624                 {
46625                         return v(ref_nested());
46626
46627                 }
46628                 protected:
46629                 template<typename V>  bool decode(size_t index, V& v)
46630                 {
46631                         clear();
46632                         switch(index)
46633                         {
46634                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CellInformation);} return false;
46635                         case 2: type = 2; return v(ref_nested());
46636                         ref_nested().clear();
46637                         }
46638                         return false;
46639
46640                 }
46641                 template<typename V> bool encode(size_t index, V& v) const
46642                 {
46643                         if(index != type) {return false;} return v(ref_nested());
46644
46645                 }
46646                 private:
46647                 size_t type {0};
46648
46649         };
46650         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
46651         {
46652                 size_t get_index() const {return type;}
46653                 bool is_unknown() const { return type == 2; }
46654                 void clear() {type = 0;}
46655                 void select_id_CellInformation() { set(ignore); type=1;}
46656                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
46657                 template<typename V>  bool decode(V& v)
46658                 {
46659                         clear();
46660                         if(!v(ref_nested())) return false;
46661                         if(equal(ignore)) { type = 1; return true; }
46662                         else { type = 2; return true;}
46663                         return false;
46664
46665                 }
46666                 template<typename V> bool encode(V& v) const
46667                 {
46668                         return v(ref_nested());
46669
46670                 }
46671                 protected:
46672                 template<typename V>  bool decode(size_t index, V& v)
46673                 {
46674                         clear();
46675                         switch(index)
46676                         {
46677                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
46678                         case 2: type = 2; return v(ref_nested());
46679                         ref_nested().clear();
46680                         }
46681                         return false;
46682
46683                 }
46684                 template<typename V> bool encode(size_t index, V& v) const
46685                 {
46686                         if(index != type) {return false;} return v(ref_nested());
46687
46688                 }
46689                 private:
46690                 size_t type {0};
46691
46692         };
46693         struct Value_t : asn::typefield<true>
46694         {
46695                 ~Value_t()      {clear();}
46696                 size_t get_index() const {return type;}
46697                 CellInformation_List& select_id_CellInformation() { return set<CellInformation_List>(1); }
46698                 CellInformation_List const* get_id_CellInformation() const { return get<CellInformation_List>(1); }
46699                 bool is_unknown() const { return type == 2; }
46700                 void clear()
46701                 {
46702                         switch(type)
46703                         {
46704                         case 1: var.destroy<CellInformation_List>(); break;
46705                         }
46706                         type = 0; ref_nested().clear();
46707                 }
46708                 template<typename V> static inline void enumerate(V& v)
46709                 {
46710                         v.template operator()<CellInformation_List>(1);
46711
46712                 }
46713                 protected:
46714                 template<typename V> bool decode(size_t index, V& v)
46715                 {
46716                         clear();
46717                         switch(index)
46718                         {
46719                         case 1: v(select_id_CellInformation()); return true;
46720                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
46721                         }
46722                         return false;
46723
46724                 }
46725                 template<typename V> bool encode(size_t index, V& v) const
46726                 {
46727                         if(index != type) return false;
46728                         switch(type)
46729                         {
46730                         case 1: v(var.as<CellInformation_List>()); return true;
46731                         }
46732                         return false;
46733
46734                 }
46735                 private:
46736                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
46737                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
46738                 union union_type
46739                 {
46740                         char dummy1[sizeof(CellInformation_List)];
46741
46742                 };
46743                 asn::variant<sizeof(union_type)> var;
46744                 size_t type {0};
46745
46746         };
46747         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
46748         {
46749                 size_t get_index() const {return type;}
46750                 bool is_unknown() const { return type == 2; }
46751                 void clear() {type = 0;}
46752                 void select_id_CellInformation() { set(mandatory); type=1;}
46753                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
46754                 template<typename V>  bool decode(V& v)
46755                 {
46756                         clear();
46757                         if(!v(ref_nested())) return false;
46758                         if(equal(mandatory)) { type = 1; return true; }
46759                         else { type = 2; return true;}
46760                         return false;
46761
46762                 }
46763                 template<typename V> bool encode(V& v) const
46764                 {
46765                         return v(ref_nested());
46766
46767                 }
46768                 protected:
46769                 template<typename V>  bool decode(size_t index, V& v)
46770                 {
46771                         clear();
46772                         switch(index)
46773                         {
46774                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
46775                         case 2: type = 2; return v(ref_nested());
46776                         ref_nested().clear();
46777                         }
46778                         return false;
46779
46780                 }
46781                 template<typename V> bool encode(size_t index, V& v) const
46782                 {
46783                         if(index != type) {return false;} return v(ref_nested());
46784
46785                 }
46786                 private:
46787                 size_t type {0};
46788
46789         };
46790
46791 };
46792 /*
46793 LoadInformation ::= SEQUENCE {
46794         protocolIEs             ProtocolIE-Container    {{LoadInformation-IEs}},
46795         ...
46796 }
46797 */
46798
46799 struct LoadInformation : asn::sequence<1, 0, true, 0>
46800 {
46801         static constexpr const char* name() {return "LoadInformation";}
46802         using parent_t = asn::sequence<1, 0, true, 0>;
46803         struct protocolIEs_t : ProtocolIE_Container<LoadInformation_IEs>
46804         {
46805                 static constexpr const char* name() {return "protocolIEs_t";}
46806                 using parent_t = ProtocolIE_Container<LoadInformation_IEs>;
46807
46808         };
46809         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
46810         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
46811         template<typename V> void decode(V& v)
46812         {
46813                 v(protocolIEs);
46814
46815         };
46816         template<typename V> void encode(V& v) const
46817         {
46818                 v(protocolIEs);
46819
46820         };
46821         void clear()
46822         {
46823                 protocolIEs.clear();
46824
46825         };
46826         private:
46827         protocolIEs_t   protocolIEs;
46828
46829 };
46830 /*
46831 MeasurementInitiationResult-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
46832         ...
46833 }
46834 */
46835
46836 struct MeasurementInitiationResult_Item_ExtIEs
46837 {
46838         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
46839         {
46840                 size_t get_index() const {return type;}
46841                 bool is_unknown() const { return type == 1; }
46842                 void clear() {type = 0;}
46843                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
46844                 template<typename V>  bool decode(V& v)
46845                 {
46846                         clear();
46847                         if(!v(ref_nested())) return false;
46848                         { type = 1; return true;}
46849                         return false;
46850
46851                 }
46852                 template<typename V> bool encode(V& v) const
46853                 {
46854                         return v(ref_nested());
46855
46856                 }
46857                 protected:
46858                 template<typename V>  bool decode(size_t index, V& v)
46859                 {
46860                         clear();
46861                         switch(index)
46862                         {
46863                         case 1: type = 1; return v(ref_nested());
46864                         ref_nested().clear();
46865                         }
46866                         return false;
46867
46868                 }
46869                 template<typename V> bool encode(size_t index, V& v) const
46870                 {
46871                         if(index != type) {return false;} return v(ref_nested());
46872
46873                 }
46874                 private:
46875                 size_t type {0};
46876
46877         };
46878         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
46879         {
46880                 size_t get_index() const {return type;}
46881                 bool is_unknown() const { return type == 1; }
46882                 void clear() {type = 0;}
46883                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
46884                 template<typename V>  bool decode(V& v)
46885                 {
46886                         clear();
46887                         if(!v(ref_nested())) return false;
46888                         { type = 1; return true;}
46889                         return false;
46890
46891                 }
46892                 template<typename V> bool encode(V& v) const
46893                 {
46894                         return v(ref_nested());
46895
46896                 }
46897                 protected:
46898                 template<typename V>  bool decode(size_t index, V& v)
46899                 {
46900                         clear();
46901                         switch(index)
46902                         {
46903                         case 1: type = 1; return v(ref_nested());
46904                         ref_nested().clear();
46905                         }
46906                         return false;
46907
46908                 }
46909                 template<typename V> bool encode(size_t index, V& v) const
46910                 {
46911                         if(index != type) {return false;} return v(ref_nested());
46912
46913                 }
46914                 private:
46915                 size_t type {0};
46916
46917         };
46918         struct Extension_t : asn::typefield<true>
46919         {
46920                 ~Extension_t()  {clear();}
46921                 size_t get_index() const {return type;}
46922                 bool is_unknown() const { return type == 1; }
46923                 void clear()
46924                 {
46925                         type = 0; ref_nested().clear();
46926                 }
46927                 template<typename V> static inline void enumerate(V& v)
46928                 {
46929
46930                 }
46931                 protected:
46932                 template<typename V> bool decode(size_t index, V& v)
46933                 {
46934                         clear();
46935                         switch(index)
46936                         {
46937                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
46938                         }
46939                         return false;
46940
46941                 }
46942                 template<typename V> bool encode(size_t index, V& v) const
46943                 {
46944                         if(index != type) return false;
46945                         return false;
46946
46947                 }
46948                 private:
46949                 size_t type {0};
46950
46951         };
46952         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
46953         {
46954                 size_t get_index() const {return type;}
46955                 bool is_unknown() const { return type == 1; }
46956                 void clear() {type = 0;}
46957                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
46958                 template<typename V>  bool decode(V& v)
46959                 {
46960                         clear();
46961                         if(!v(ref_nested())) return false;
46962                         { type = 1; return true;}
46963                         return false;
46964
46965                 }
46966                 template<typename V> bool encode(V& v) const
46967                 {
46968                         return v(ref_nested());
46969
46970                 }
46971                 protected:
46972                 template<typename V>  bool decode(size_t index, V& v)
46973                 {
46974                         clear();
46975                         switch(index)
46976                         {
46977                         case 1: type = 1; return v(ref_nested());
46978                         ref_nested().clear();
46979                         }
46980                         return false;
46981
46982                 }
46983                 template<typename V> bool encode(size_t index, V& v) const
46984                 {
46985                         if(index != type) {return false;} return v(ref_nested());
46986
46987                 }
46988                 private:
46989                 size_t type {0};
46990
46991         };
46992
46993 };
46994 /*
46995 MeasurementInitiationResult-Item ::= SEQUENCE {
46996         cell-ID                                                                                 ECGI,
46997         measurementFailureCause-List                                    MeasurementFailureCause-List    OPTIONAL,
46998         iE-Extensions                                                                   ProtocolExtensionContainer { {MeasurementInitiationResult-Item-ExtIEs} }        OPTIONAL,
46999         ...
47000 }
47001 */
47002
47003 struct MeasurementInitiationResult_Item : asn::sequence<3, 0, true, 2>
47004 {
47005         static constexpr const char* name() {return "MeasurementInitiationResult-Item";}
47006         using parent_t = asn::sequence<3, 0, true, 2>;
47007         struct cell_ID_t : ECGI
47008         {
47009                 static constexpr const char* name() {return "cell_ID_t";}
47010                 using parent_t = ECGI;
47011
47012         };
47013         cell_ID_t& ref_cell_ID() {return cell_ID;}
47014         cell_ID_t const& ref_cell_ID() const {return cell_ID;}
47015         struct measurementFailureCause_List_t : MeasurementFailureCause_List
47016         {
47017                 static constexpr const char* name() {return "measurementFailureCause_List_t";}
47018                 using parent_t = MeasurementFailureCause_List;
47019                 static constexpr bool optional = true;
47020
47021         };
47022         measurementFailureCause_List_t& set_measurementFailureCause_List() { measurementFailureCause_List.setpresent(true); return measurementFailureCause_List;}
47023         measurementFailureCause_List_t const* get_measurementFailureCause_List() const {return measurementFailureCause_List.is_valid() ? &measurementFailureCause_List : nullptr;}
47024         struct iE_Extensions_t : ProtocolExtensionContainer<MeasurementInitiationResult_Item_ExtIEs>
47025         {
47026                 static constexpr const char* name() {return "iE_Extensions_t";}
47027                 using parent_t = ProtocolExtensionContainer<MeasurementInitiationResult_Item_ExtIEs>;
47028                 static constexpr bool optional = true;
47029
47030         };
47031         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
47032         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
47033         template<typename V> void decode(V& v)
47034         {
47035                 v(cell_ID);
47036                 v(measurementFailureCause_List);
47037                 v(iE_Extensions);
47038
47039         };
47040         template<typename V> void encode(V& v) const
47041         {
47042                 v(cell_ID);
47043                 v(measurementFailureCause_List);
47044                 v(iE_Extensions);
47045
47046         };
47047         void clear()
47048         {
47049                 cell_ID.clear();
47050                 measurementFailureCause_List.clear();
47051                 iE_Extensions.clear();
47052
47053         };
47054         private:
47055         cell_ID_t       cell_ID;
47056         measurementFailureCause_List_t  measurementFailureCause_List;
47057         iE_Extensions_t iE_Extensions;
47058
47059 };
47060 /*
47061 MeasurementInitiationResult-ItemIEs X2AP-PROTOCOL-IES ::= {
47062         { ID id-MeasurementInitiationResult-Item        CRITICALITY ignore      TYPE MeasurementInitiationResult-Item   PRESENCE mandatory}
47063 }
47064 */
47065
47066 struct MeasurementInitiationResult_ItemIEs
47067 {
47068         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, false>
47069         {
47070                 size_t get_index() const {return type;}
47071                 void clear() {type = 0;}
47072                 void select_id_MeasurementInitiationResult_Item() { set(id_MeasurementInitiationResult_Item); type=1;}
47073                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47074                 template<typename V>  bool decode(V& v)
47075                 {
47076                         clear();
47077                         if(!v(ref_nested())) return false;
47078                         if(equal(id_MeasurementInitiationResult_Item)) { type = 1; return true; }
47079                         return false;
47080
47081                 }
47082                 template<typename V> bool encode(V& v) const
47083                 {
47084                         return v(ref_nested());
47085
47086                 }
47087                 protected:
47088                 template<typename V>  bool decode(size_t index, V& v)
47089                 {
47090                         clear();
47091                         switch(index)
47092                         {
47093                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeasurementInitiationResult_Item);} return false;
47094                         ref_nested().clear();
47095                         }
47096                         return false;
47097
47098                 }
47099                 template<typename V> bool encode(size_t index, V& v) const
47100                 {
47101                         if(index != type) {return false;} return v(ref_nested());
47102
47103                 }
47104                 private:
47105                 size_t type {0};
47106
47107         };
47108         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, false>
47109         {
47110                 size_t get_index() const {return type;}
47111                 void clear() {type = 0;}
47112                 void select_id_MeasurementInitiationResult_Item() { set(ignore); type=1;}
47113                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47114                 template<typename V>  bool decode(V& v)
47115                 {
47116                         clear();
47117                         if(!v(ref_nested())) return false;
47118                         if(equal(ignore)) { type = 1; return true; }
47119                         return false;
47120
47121                 }
47122                 template<typename V> bool encode(V& v) const
47123                 {
47124                         return v(ref_nested());
47125
47126                 }
47127                 protected:
47128                 template<typename V>  bool decode(size_t index, V& v)
47129                 {
47130                         clear();
47131                         switch(index)
47132                         {
47133                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
47134                         ref_nested().clear();
47135                         }
47136                         return false;
47137
47138                 }
47139                 template<typename V> bool encode(size_t index, V& v) const
47140                 {
47141                         if(index != type) {return false;} return v(ref_nested());
47142
47143                 }
47144                 private:
47145                 size_t type {0};
47146
47147         };
47148         struct Value_t : asn::typefield<false>
47149         {
47150                 ~Value_t()      {clear();}
47151                 size_t get_index() const {return type;}
47152                 MeasurementInitiationResult_Item& select_id_MeasurementInitiationResult_Item() { return set<MeasurementInitiationResult_Item>(1); }
47153                 MeasurementInitiationResult_Item const* get_id_MeasurementInitiationResult_Item() const { return get<MeasurementInitiationResult_Item>(1); }
47154                 void clear()
47155                 {
47156                         switch(type)
47157                         {
47158                         case 1: var.destroy<MeasurementInitiationResult_Item>(); break;
47159                         }
47160                         type = 0; ref_nested().clear();
47161                 }
47162                 template<typename V> static inline void enumerate(V& v)
47163                 {
47164                         v.template operator()<MeasurementInitiationResult_Item>(1);
47165
47166                 }
47167                 protected:
47168                 template<typename V> bool decode(size_t index, V& v)
47169                 {
47170                         clear();
47171                         switch(index)
47172                         {
47173                         case 1: v(select_id_MeasurementInitiationResult_Item()); return true;
47174                         }
47175                         return false;
47176
47177                 }
47178                 template<typename V> bool encode(size_t index, V& v) const
47179                 {
47180                         if(index != type) return false;
47181                         switch(type)
47182                         {
47183                         case 1: v(var.as<MeasurementInitiationResult_Item>()); return true;
47184                         }
47185                         return false;
47186
47187                 }
47188                 private:
47189                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47190                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47191                 union union_type
47192                 {
47193                         char dummy1[sizeof(MeasurementInitiationResult_Item)];
47194
47195                 };
47196                 asn::variant<sizeof(union_type)> var;
47197                 size_t type {0};
47198
47199         };
47200         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, false>
47201         {
47202                 size_t get_index() const {return type;}
47203                 void clear() {type = 0;}
47204                 void select_id_MeasurementInitiationResult_Item() { set(mandatory); type=1;}
47205                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47206                 template<typename V>  bool decode(V& v)
47207                 {
47208                         clear();
47209                         if(!v(ref_nested())) return false;
47210                         if(equal(mandatory)) { type = 1; return true; }
47211                         return false;
47212
47213                 }
47214                 template<typename V> bool encode(V& v) const
47215                 {
47216                         return v(ref_nested());
47217
47218                 }
47219                 protected:
47220                 template<typename V>  bool decode(size_t index, V& v)
47221                 {
47222                         clear();
47223                         switch(index)
47224                         {
47225                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47226                         ref_nested().clear();
47227                         }
47228                         return false;
47229
47230                 }
47231                 template<typename V> bool encode(size_t index, V& v) const
47232                 {
47233                         if(index != type) {return false;} return v(ref_nested());
47234
47235                 }
47236                 private:
47237                 size_t type {0};
47238
47239         };
47240
47241 };
47242 /*
47243 MeasurementInitiationResult-List ::= SEQUENCE (SIZE (1..maxCellineNB)) OF ProtocolIE-Single-Container { {MeasurementInitiationResult-ItemIEs} }
47244 */
47245
47246 struct MeasurementInitiationResult_List_elm : ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>
47247 {
47248         static constexpr const char* name() {return "MeasurementInitiationResult_List_elm";}
47249         using parent_t = ProtocolIE_Single_Container<MeasurementInitiationResult_ItemIEs>;
47250
47251 };
47252 struct MeasurementInitiationResult_List : asn::sequenceof<MeasurementInitiationResult_List_elm>
47253 {
47254         static constexpr const char* name() {return "MeasurementInitiationResult-List";}
47255         using parent_t = asn::sequenceof<MeasurementInitiationResult_List_elm>;
47256         using constraint_t = asn::constraints<false,asn::span<1,  maxCellineNB >>;
47257
47258 };
47259 /*
47260 MobilityChangeAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
47261         { ID id-ENB1-Cell-ID                    CRITICALITY reject      TYPE ECGI                                                       PRESENCE mandatory}|
47262         { ID id-ENB2-Cell-ID                    CRITICALITY reject      TYPE ECGI                                                       PRESENCE mandatory}|
47263         { ID id-CriticalityDiagnostics  CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional},
47264         ...
47265 }
47266 */
47267
47268 struct MobilityChangeAcknowledge_IEs
47269 {
47270         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47271         {
47272                 size_t get_index() const {return type;}
47273                 bool is_unknown() const { return type == 4; }
47274                 void clear() {type = 0;}
47275                 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47276                 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47277                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
47278                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47279                 template<typename V>  bool decode(V& v)
47280                 {
47281                         clear();
47282                         if(!v(ref_nested())) return false;
47283                         if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47284                         else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47285                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
47286                         else { type = 4; return true;}
47287                         return false;
47288
47289                 }
47290                 template<typename V> bool encode(V& v) const
47291                 {
47292                         return v(ref_nested());
47293
47294                 }
47295                 protected:
47296                 template<typename V>  bool decode(size_t index, V& v)
47297                 {
47298                         clear();
47299                         switch(index)
47300                         {
47301                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47302                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47303                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
47304                         case 4: type = 4; return v(ref_nested());
47305                         ref_nested().clear();
47306                         }
47307                         return false;
47308
47309                 }
47310                 template<typename V> bool encode(size_t index, V& v) const
47311                 {
47312                         if(index != type) {return false;} return v(ref_nested());
47313
47314                 }
47315                 private:
47316                 size_t type {0};
47317
47318         };
47319         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47320         {
47321                 size_t get_index() const {return type;}
47322                 bool is_unknown() const { return type == 4; }
47323                 void clear() {type = 0;}
47324                 void select_id_ENB1_Cell_ID() { set(reject); type=1;}
47325                 void select_id_ENB2_Cell_ID() { set(reject); type=2;}
47326                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
47327                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47328                 template<typename V>  bool decode(V& v)
47329                 {
47330                         clear();
47331                         if(!v(ref_nested())) return false;
47332                         if(equal(reject)) { type = 1; return true; }
47333                         else if(equal(reject)) { type = 2; return true; }
47334                         else if(equal(ignore)) { type = 3; return true; }
47335                         else { type = 4; return true;}
47336                         return false;
47337
47338                 }
47339                 template<typename V> bool encode(V& v) const
47340                 {
47341                         return v(ref_nested());
47342
47343                 }
47344                 protected:
47345                 template<typename V>  bool decode(size_t index, V& v)
47346                 {
47347                         clear();
47348                         switch(index)
47349                         {
47350                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
47351                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
47352                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47353                         case 4: type = 4; return v(ref_nested());
47354                         ref_nested().clear();
47355                         }
47356                         return false;
47357
47358                 }
47359                 template<typename V> bool encode(size_t index, V& v) const
47360                 {
47361                         if(index != type) {return false;} return v(ref_nested());
47362
47363                 }
47364                 private:
47365                 size_t type {0};
47366
47367         };
47368         struct Value_t : asn::typefield<true>
47369         {
47370                 ~Value_t()      {clear();}
47371                 size_t get_index() const {return type;}
47372                 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47373                 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47374                 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47375                 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47376                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
47377                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
47378                 bool is_unknown() const { return type == 4; }
47379                 void clear()
47380                 {
47381                         switch(type)
47382                         {
47383                         case 1: var.destroy<ECGI>(); break;
47384                         case 2: var.destroy<ECGI>(); break;
47385                         case 3: var.destroy<CriticalityDiagnostics>(); break;
47386                         }
47387                         type = 0; ref_nested().clear();
47388                 }
47389                 template<typename V> static inline void enumerate(V& v)
47390                 {
47391                         v.template operator()<ECGI>(1);
47392                         v.template operator()<ECGI>(2);
47393                         v.template operator()<CriticalityDiagnostics>(3);
47394
47395                 }
47396                 protected:
47397                 template<typename V> bool decode(size_t index, V& v)
47398                 {
47399                         clear();
47400                         switch(index)
47401                         {
47402                         case 1: v(select_id_ENB1_Cell_ID()); return true;
47403                         case 2: v(select_id_ENB2_Cell_ID()); return true;
47404                         case 3: v(select_id_CriticalityDiagnostics()); return true;
47405                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
47406                         }
47407                         return false;
47408
47409                 }
47410                 template<typename V> bool encode(size_t index, V& v) const
47411                 {
47412                         if(index != type) return false;
47413                         switch(type)
47414                         {
47415                         case 1: v(var.as<ECGI>()); return true;
47416                         case 2: v(var.as<ECGI>()); return true;
47417                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
47418                         }
47419                         return false;
47420
47421                 }
47422                 private:
47423                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47424                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47425                 union union_type
47426                 {
47427                         char dummy1[sizeof(CriticalityDiagnostics)];
47428                         char dummy2[sizeof(ECGI)];
47429
47430                 };
47431                 asn::variant<sizeof(union_type)> var;
47432                 size_t type {0};
47433
47434         };
47435         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
47436         {
47437                 size_t get_index() const {return type;}
47438                 bool is_unknown() const { return type == 4; }
47439                 void clear() {type = 0;}
47440                 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
47441                 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
47442                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
47443                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47444                 template<typename V>  bool decode(V& v)
47445                 {
47446                         clear();
47447                         if(!v(ref_nested())) return false;
47448                         if(equal(mandatory)) { type = 1; return true; }
47449                         else if(equal(mandatory)) { type = 2; return true; }
47450                         else if(equal(optional)) { type = 3; return true; }
47451                         else { type = 4; return true;}
47452                         return false;
47453
47454                 }
47455                 template<typename V> bool encode(V& v) const
47456                 {
47457                         return v(ref_nested());
47458
47459                 }
47460                 protected:
47461                 template<typename V>  bool decode(size_t index, V& v)
47462                 {
47463                         clear();
47464                         switch(index)
47465                         {
47466                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47467                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
47468                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
47469                         case 4: type = 4; return v(ref_nested());
47470                         ref_nested().clear();
47471                         }
47472                         return false;
47473
47474                 }
47475                 template<typename V> bool encode(size_t index, V& v) const
47476                 {
47477                         if(index != type) {return false;} return v(ref_nested());
47478
47479                 }
47480                 private:
47481                 size_t type {0};
47482
47483         };
47484
47485 };
47486 /*
47487 MobilityChangeAcknowledge ::= SEQUENCE {
47488         protocolIEs             ProtocolIE-Container    {{MobilityChangeAcknowledge-IEs}},
47489         ...
47490 }
47491 */
47492
47493 struct MobilityChangeAcknowledge : asn::sequence<1, 0, true, 0>
47494 {
47495         static constexpr const char* name() {return "MobilityChangeAcknowledge";}
47496         using parent_t = asn::sequence<1, 0, true, 0>;
47497         struct protocolIEs_t : ProtocolIE_Container<MobilityChangeAcknowledge_IEs>
47498         {
47499                 static constexpr const char* name() {return "protocolIEs_t";}
47500                 using parent_t = ProtocolIE_Container<MobilityChangeAcknowledge_IEs>;
47501
47502         };
47503         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
47504         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
47505         template<typename V> void decode(V& v)
47506         {
47507                 v(protocolIEs);
47508
47509         };
47510         template<typename V> void encode(V& v) const
47511         {
47512                 v(protocolIEs);
47513
47514         };
47515         void clear()
47516         {
47517                 protocolIEs.clear();
47518
47519         };
47520         private:
47521         protocolIEs_t   protocolIEs;
47522
47523 };
47524 /*
47525 MobilityChangeFailure-IEs X2AP-PROTOCOL-IES ::= {
47526         { ID id-ENB1-Cell-ID                                                                    CRITICALITY ignore      TYPE ECGI                                                                                               PRESENCE mandatory}|
47527         { ID id-ENB2-Cell-ID                                                                    CRITICALITY ignore      TYPE ECGI                                                                                               PRESENCE mandatory}|
47528         { ID id-Cause                                                                                   CRITICALITY ignore      TYPE Cause                                                                                              PRESENCE mandatory}|
47529         { ID id-ENB2-Mobility-Parameters-Modification-Range             CRITICALITY ignore      TYPE MobilityParametersModificationRange                PRESENCE optional}|
47530         { ID id-CriticalityDiagnostics                                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional},
47531         ...
47532 }
47533 */
47534
47535 struct MobilityChangeFailure_IEs
47536 {
47537         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47538         {
47539                 size_t get_index() const {return type;}
47540                 bool is_unknown() const { return type == 6; }
47541                 void clear() {type = 0;}
47542                 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47543                 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47544                 void select_id_Cause() { set(id_Cause); type=3;}
47545                 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(id_ENB2_Mobility_Parameters_Modification_Range); type=4;}
47546                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
47547                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47548                 template<typename V>  bool decode(V& v)
47549                 {
47550                         clear();
47551                         if(!v(ref_nested())) return false;
47552                         if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47553                         else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47554                         else if(equal(id_Cause)) { type = 3; return true; }
47555                         else if(equal(id_ENB2_Mobility_Parameters_Modification_Range)) { type = 4; return true; }
47556                         else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
47557                         else { type = 6; return true;}
47558                         return false;
47559
47560                 }
47561                 template<typename V> bool encode(V& v) const
47562                 {
47563                         return v(ref_nested());
47564
47565                 }
47566                 protected:
47567                 template<typename V>  bool decode(size_t index, V& v)
47568                 {
47569                         clear();
47570                         switch(index)
47571                         {
47572                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47573                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47574                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
47575                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Mobility_Parameters_Modification_Range);} return false;
47576                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
47577                         case 6: type = 6; return v(ref_nested());
47578                         ref_nested().clear();
47579                         }
47580                         return false;
47581
47582                 }
47583                 template<typename V> bool encode(size_t index, V& v) const
47584                 {
47585                         if(index != type) {return false;} return v(ref_nested());
47586
47587                 }
47588                 private:
47589                 size_t type {0};
47590
47591         };
47592         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47593         {
47594                 size_t get_index() const {return type;}
47595                 bool is_unknown() const { return type == 6; }
47596                 void clear() {type = 0;}
47597                 void select_id_ENB1_Cell_ID() { set(ignore); type=1;}
47598                 void select_id_ENB2_Cell_ID() { set(ignore); type=2;}
47599                 void select_id_Cause() { set(ignore); type=3;}
47600                 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(ignore); type=4;}
47601                 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
47602                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47603                 template<typename V>  bool decode(V& v)
47604                 {
47605                         clear();
47606                         if(!v(ref_nested())) return false;
47607                         if(equal(ignore)) { type = 1; return true; }
47608                         else if(equal(ignore)) { type = 2; return true; }
47609                         else if(equal(ignore)) { type = 3; return true; }
47610                         else if(equal(ignore)) { type = 4; return true; }
47611                         else if(equal(ignore)) { type = 5; return true; }
47612                         else { type = 6; return true;}
47613                         return false;
47614
47615                 }
47616                 template<typename V> bool encode(V& v) const
47617                 {
47618                         return v(ref_nested());
47619
47620                 }
47621                 protected:
47622                 template<typename V>  bool decode(size_t index, V& v)
47623                 {
47624                         clear();
47625                         switch(index)
47626                         {
47627                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
47628                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
47629                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47630                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
47631                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
47632                         case 6: type = 6; return v(ref_nested());
47633                         ref_nested().clear();
47634                         }
47635                         return false;
47636
47637                 }
47638                 template<typename V> bool encode(size_t index, V& v) const
47639                 {
47640                         if(index != type) {return false;} return v(ref_nested());
47641
47642                 }
47643                 private:
47644                 size_t type {0};
47645
47646         };
47647         struct Value_t : asn::typefield<true>
47648         {
47649                 ~Value_t()      {clear();}
47650                 size_t get_index() const {return type;}
47651                 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47652                 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47653                 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47654                 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47655                 Cause& select_id_Cause() { return set<Cause>(3); }
47656                 Cause const* get_id_Cause() const { return get<Cause>(3); }
47657                 MobilityParametersModificationRange& select_id_ENB2_Mobility_Parameters_Modification_Range() { return set<MobilityParametersModificationRange>(4); }
47658                 MobilityParametersModificationRange const* get_id_ENB2_Mobility_Parameters_Modification_Range() const { return get<MobilityParametersModificationRange>(4); }
47659                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
47660                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
47661                 bool is_unknown() const { return type == 6; }
47662                 void clear()
47663                 {
47664                         switch(type)
47665                         {
47666                         case 1: var.destroy<ECGI>(); break;
47667                         case 2: var.destroy<ECGI>(); break;
47668                         case 3: var.destroy<Cause>(); break;
47669                         case 4: var.destroy<MobilityParametersModificationRange>(); break;
47670                         case 5: var.destroy<CriticalityDiagnostics>(); break;
47671                         }
47672                         type = 0; ref_nested().clear();
47673                 }
47674                 template<typename V> static inline void enumerate(V& v)
47675                 {
47676                         v.template operator()<ECGI>(1);
47677                         v.template operator()<ECGI>(2);
47678                         v.template operator()<Cause>(3);
47679                         v.template operator()<MobilityParametersModificationRange>(4);
47680                         v.template operator()<CriticalityDiagnostics>(5);
47681
47682                 }
47683                 protected:
47684                 template<typename V> bool decode(size_t index, V& v)
47685                 {
47686                         clear();
47687                         switch(index)
47688                         {
47689                         case 1: v(select_id_ENB1_Cell_ID()); return true;
47690                         case 2: v(select_id_ENB2_Cell_ID()); return true;
47691                         case 3: v(select_id_Cause()); return true;
47692                         case 4: v(select_id_ENB2_Mobility_Parameters_Modification_Range()); return true;
47693                         case 5: v(select_id_CriticalityDiagnostics()); return true;
47694                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
47695                         }
47696                         return false;
47697
47698                 }
47699                 template<typename V> bool encode(size_t index, V& v) const
47700                 {
47701                         if(index != type) return false;
47702                         switch(type)
47703                         {
47704                         case 1: v(var.as<ECGI>()); return true;
47705                         case 2: v(var.as<ECGI>()); return true;
47706                         case 3: v(var.as<Cause>()); return true;
47707                         case 4: v(var.as<MobilityParametersModificationRange>()); return true;
47708                         case 5: v(var.as<CriticalityDiagnostics>()); return true;
47709                         }
47710                         return false;
47711
47712                 }
47713                 private:
47714                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
47715                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
47716                 union union_type
47717                 {
47718                         char dummy1[sizeof(Cause)];
47719                         char dummy2[sizeof(CriticalityDiagnostics)];
47720                         char dummy3[sizeof(ECGI)];
47721                         char dummy4[sizeof(MobilityParametersModificationRange)];
47722
47723                 };
47724                 asn::variant<sizeof(union_type)> var;
47725                 size_t type {0};
47726
47727         };
47728         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
47729         {
47730                 size_t get_index() const {return type;}
47731                 bool is_unknown() const { return type == 6; }
47732                 void clear() {type = 0;}
47733                 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
47734                 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
47735                 void select_id_Cause() { set(mandatory); type=3;}
47736                 void select_id_ENB2_Mobility_Parameters_Modification_Range() { set(optional); type=4;}
47737                 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
47738                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
47739                 template<typename V>  bool decode(V& v)
47740                 {
47741                         clear();
47742                         if(!v(ref_nested())) return false;
47743                         if(equal(mandatory)) { type = 1; return true; }
47744                         else if(equal(mandatory)) { type = 2; return true; }
47745                         else if(equal(mandatory)) { type = 3; return true; }
47746                         else if(equal(optional)) { type = 4; return true; }
47747                         else if(equal(optional)) { type = 5; return true; }
47748                         else { type = 6; return true;}
47749                         return false;
47750
47751                 }
47752                 template<typename V> bool encode(V& v) const
47753                 {
47754                         return v(ref_nested());
47755
47756                 }
47757                 protected:
47758                 template<typename V>  bool decode(size_t index, V& v)
47759                 {
47760                         clear();
47761                         switch(index)
47762                         {
47763                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
47764                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
47765                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
47766                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
47767                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
47768                         case 6: type = 6; return v(ref_nested());
47769                         ref_nested().clear();
47770                         }
47771                         return false;
47772
47773                 }
47774                 template<typename V> bool encode(size_t index, V& v) const
47775                 {
47776                         if(index != type) {return false;} return v(ref_nested());
47777
47778                 }
47779                 private:
47780                 size_t type {0};
47781
47782         };
47783
47784 };
47785 /*
47786 MobilityChangeFailure ::= SEQUENCE {
47787         protocolIEs             ProtocolIE-Container    {{MobilityChangeFailure-IEs}},
47788         ...
47789 }
47790 */
47791
47792 struct MobilityChangeFailure : asn::sequence<1, 0, true, 0>
47793 {
47794         static constexpr const char* name() {return "MobilityChangeFailure";}
47795         using parent_t = asn::sequence<1, 0, true, 0>;
47796         struct protocolIEs_t : ProtocolIE_Container<MobilityChangeFailure_IEs>
47797         {
47798                 static constexpr const char* name() {return "protocolIEs_t";}
47799                 using parent_t = ProtocolIE_Container<MobilityChangeFailure_IEs>;
47800
47801         };
47802         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
47803         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
47804         template<typename V> void decode(V& v)
47805         {
47806                 v(protocolIEs);
47807
47808         };
47809         template<typename V> void encode(V& v) const
47810         {
47811                 v(protocolIEs);
47812
47813         };
47814         void clear()
47815         {
47816                 protocolIEs.clear();
47817
47818         };
47819         private:
47820         protocolIEs_t   protocolIEs;
47821
47822 };
47823 /*
47824 MobilityChangeRequest-IEs X2AP-PROTOCOL-IES ::= {
47825         { ID id-ENB1-Cell-ID                                            CRITICALITY reject      TYPE ECGI                                                                                       PRESENCE mandatory}|
47826         { ID id-ENB2-Cell-ID                                            CRITICALITY reject      TYPE ECGI                                                                                       PRESENCE mandatory}|
47827         { ID id-ENB1-Mobility-Parameters                        CRITICALITY ignore      TYPE MobilityParametersInformation                              PRESENCE optional}|
47828         { ID id-ENB2-Proposed-Mobility-Parameters       CRITICALITY reject      TYPE MobilityParametersInformation                              PRESENCE mandatory}|
47829         { ID id-Cause                                                           CRITICALITY reject      TYPE Cause                                                                                      PRESENCE mandatory},
47830         ...
47831 }
47832 */
47833
47834 struct MobilityChangeRequest_IEs
47835 {
47836         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
47837         {
47838                 size_t get_index() const {return type;}
47839                 bool is_unknown() const { return type == 6; }
47840                 void clear() {type = 0;}
47841                 void select_id_ENB1_Cell_ID() { set(id_ENB1_Cell_ID); type=1;}
47842                 void select_id_ENB2_Cell_ID() { set(id_ENB2_Cell_ID); type=2;}
47843                 void select_id_ENB1_Mobility_Parameters() { set(id_ENB1_Mobility_Parameters); type=3;}
47844                 void select_id_ENB2_Proposed_Mobility_Parameters() { set(id_ENB2_Proposed_Mobility_Parameters); type=4;}
47845                 void select_id_Cause() { set(id_Cause); type=5;}
47846                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
47847                 template<typename V>  bool decode(V& v)
47848                 {
47849                         clear();
47850                         if(!v(ref_nested())) return false;
47851                         if(equal(id_ENB1_Cell_ID)) { type = 1; return true; }
47852                         else if(equal(id_ENB2_Cell_ID)) { type = 2; return true; }
47853                         else if(equal(id_ENB1_Mobility_Parameters)) { type = 3; return true; }
47854                         else if(equal(id_ENB2_Proposed_Mobility_Parameters)) { type = 4; return true; }
47855                         else if(equal(id_Cause)) { type = 5; return true; }
47856                         else { type = 6; return true;}
47857                         return false;
47858
47859                 }
47860                 template<typename V> bool encode(V& v) const
47861                 {
47862                         return v(ref_nested());
47863
47864                 }
47865                 protected:
47866                 template<typename V>  bool decode(size_t index, V& v)
47867                 {
47868                         clear();
47869                         switch(index)
47870                         {
47871                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Cell_ID);} return false;
47872                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Cell_ID);} return false;
47873                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ENB1_Mobility_Parameters);} return false;
47874                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ENB2_Proposed_Mobility_Parameters);} return false;
47875                         case 5: type = 5; if(v(ref_nested())) { return equal(id_Cause);} return false;
47876                         case 6: type = 6; return v(ref_nested());
47877                         ref_nested().clear();
47878                         }
47879                         return false;
47880
47881                 }
47882                 template<typename V> bool encode(size_t index, V& v) const
47883                 {
47884                         if(index != type) {return false;} return v(ref_nested());
47885
47886                 }
47887                 private:
47888                 size_t type {0};
47889
47890         };
47891         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
47892         {
47893                 size_t get_index() const {return type;}
47894                 bool is_unknown() const { return type == 6; }
47895                 void clear() {type = 0;}
47896                 void select_id_ENB1_Cell_ID() { set(reject); type=1;}
47897                 void select_id_ENB2_Cell_ID() { set(reject); type=2;}
47898                 void select_id_ENB1_Mobility_Parameters() { set(ignore); type=3;}
47899                 void select_id_ENB2_Proposed_Mobility_Parameters() { set(reject); type=4;}
47900                 void select_id_Cause() { set(reject); type=5;}
47901                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
47902                 template<typename V>  bool decode(V& v)
47903                 {
47904                         clear();
47905                         if(!v(ref_nested())) return false;
47906                         if(equal(reject)) { type = 1; return true; }
47907                         else if(equal(reject)) { type = 2; return true; }
47908                         else if(equal(ignore)) { type = 3; return true; }
47909                         else if(equal(reject)) { type = 4; return true; }
47910                         else if(equal(reject)) { type = 5; return true; }
47911                         else { type = 6; return true;}
47912                         return false;
47913
47914                 }
47915                 template<typename V> bool encode(V& v) const
47916                 {
47917                         return v(ref_nested());
47918
47919                 }
47920                 protected:
47921                 template<typename V>  bool decode(size_t index, V& v)
47922                 {
47923                         clear();
47924                         switch(index)
47925                         {
47926                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
47927                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
47928                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
47929                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
47930                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
47931                         case 6: type = 6; return v(ref_nested());
47932                         ref_nested().clear();
47933                         }
47934                         return false;
47935
47936                 }
47937                 template<typename V> bool encode(size_t index, V& v) const
47938                 {
47939                         if(index != type) {return false;} return v(ref_nested());
47940
47941                 }
47942                 private:
47943                 size_t type {0};
47944
47945         };
47946         struct Value_t : asn::typefield<true>
47947         {
47948                 ~Value_t()      {clear();}
47949                 size_t get_index() const {return type;}
47950                 ECGI& select_id_ENB1_Cell_ID() { return set<ECGI>(1); }
47951                 ECGI const* get_id_ENB1_Cell_ID() const { return get<ECGI>(1); }
47952                 ECGI& select_id_ENB2_Cell_ID() { return set<ECGI>(2); }
47953                 ECGI const* get_id_ENB2_Cell_ID() const { return get<ECGI>(2); }
47954                 MobilityParametersInformation& select_id_ENB1_Mobility_Parameters() { return set<MobilityParametersInformation>(3); }
47955                 MobilityParametersInformation const* get_id_ENB1_Mobility_Parameters() const { return get<MobilityParametersInformation>(3); }
47956                 MobilityParametersInformation& select_id_ENB2_Proposed_Mobility_Parameters() { return set<MobilityParametersInformation>(4); }
47957                 MobilityParametersInformation const* get_id_ENB2_Proposed_Mobility_Parameters() const { return get<MobilityParametersInformation>(4); }
47958                 Cause& select_id_Cause() { return set<Cause>(5); }
47959                 Cause const* get_id_Cause() const { return get<Cause>(5); }
47960                 bool is_unknown() const { return type == 6; }
47961                 void clear()
47962                 {
47963                         switch(type)
47964                         {
47965                         case 1: var.destroy<ECGI>(); break;
47966                         case 2: var.destroy<ECGI>(); break;
47967                         case 3: var.destroy<MobilityParametersInformation>(); break;
47968                         case 4: var.destroy<MobilityParametersInformation>(); break;
47969                         case 5: var.destroy<Cause>(); break;
47970                         }
47971                         type = 0; ref_nested().clear();
47972                 }
47973                 template<typename V> static inline void enumerate(V& v)
47974                 {
47975                         v.template operator()<ECGI>(1);
47976                         v.template operator()<ECGI>(2);
47977                         v.template operator()<MobilityParametersInformation>(3);
47978                         v.template operator()<MobilityParametersInformation>(4);
47979                         v.template operator()<Cause>(5);
47980
47981                 }
47982                 protected:
47983                 template<typename V> bool decode(size_t index, V& v)
47984                 {
47985                         clear();
47986                         switch(index)
47987                         {
47988                         case 1: v(select_id_ENB1_Cell_ID()); return true;
47989                         case 2: v(select_id_ENB2_Cell_ID()); return true;
47990                         case 3: v(select_id_ENB1_Mobility_Parameters()); return true;
47991                         case 4: v(select_id_ENB2_Proposed_Mobility_Parameters()); return true;
47992                         case 5: v(select_id_Cause()); return true;
47993                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
47994                         }
47995                         return false;
47996
47997                 }
47998                 template<typename V> bool encode(size_t index, V& v) const
47999                 {
48000                         if(index != type) return false;
48001                         switch(type)
48002                         {
48003                         case 1: v(var.as<ECGI>()); return true;
48004                         case 2: v(var.as<ECGI>()); return true;
48005                         case 3: v(var.as<MobilityParametersInformation>()); return true;
48006                         case 4: v(var.as<MobilityParametersInformation>()); return true;
48007                         case 5: v(var.as<Cause>()); return true;
48008                         }
48009                         return false;
48010
48011                 }
48012                 private:
48013                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
48014                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
48015                 union union_type
48016                 {
48017                         char dummy1[sizeof(Cause)];
48018                         char dummy2[sizeof(ECGI)];
48019                         char dummy3[sizeof(MobilityParametersInformation)];
48020
48021                 };
48022                 asn::variant<sizeof(union_type)> var;
48023                 size_t type {0};
48024
48025         };
48026         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
48027         {
48028                 size_t get_index() const {return type;}
48029                 bool is_unknown() const { return type == 6; }
48030                 void clear() {type = 0;}
48031                 void select_id_ENB1_Cell_ID() { set(mandatory); type=1;}
48032                 void select_id_ENB2_Cell_ID() { set(mandatory); type=2;}
48033                 void select_id_ENB1_Mobility_Parameters() { set(optional); type=3;}
48034                 void select_id_ENB2_Proposed_Mobility_Parameters() { set(mandatory); type=4;}
48035                 void select_id_Cause() { set(mandatory); type=5;}
48036                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
48037                 template<typename V>  bool decode(V& v)
48038                 {
48039                         clear();
48040                         if(!v(ref_nested())) return false;
48041                         if(equal(mandatory)) { type = 1; return true; }
48042                         else if(equal(mandatory)) { type = 2; return true; }
48043                         else if(equal(optional)) { type = 3; return true; }
48044                         else if(equal(mandatory)) { type = 4; return true; }
48045                         else if(equal(mandatory)) { type = 5; return true; }
48046                         else { type = 6; return true;}
48047                         return false;
48048
48049                 }
48050                 template<typename V> bool encode(V& v) const
48051                 {
48052                         return v(ref_nested());
48053
48054                 }
48055                 protected:
48056                 template<typename V>  bool decode(size_t index, V& v)
48057                 {
48058                         clear();
48059                         switch(index)
48060                         {
48061                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
48062                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
48063                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
48064                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
48065                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
48066                         case 6: type = 6; return v(ref_nested());
48067                         ref_nested().clear();
48068                         }
48069                         return false;
48070
48071                 }
48072                 template<typename V> bool encode(size_t index, V& v) const
48073                 {
48074                         if(index != type) {return false;} return v(ref_nested());
48075
48076                 }
48077                 private:
48078                 size_t type {0};
48079
48080         };
48081
48082 };
48083 /*
48084 MobilityChangeRequest ::= SEQUENCE {
48085         protocolIEs             ProtocolIE-Container    {{MobilityChangeRequest-IEs}},
48086         ...
48087 }
48088 */
48089
48090 struct MobilityChangeRequest : asn::sequence<1, 0, true, 0>
48091 {
48092         static constexpr const char* name() {return "MobilityChangeRequest";}
48093         using parent_t = asn::sequence<1, 0, true, 0>;
48094         struct protocolIEs_t : ProtocolIE_Container<MobilityChangeRequest_IEs>
48095         {
48096                 static constexpr const char* name() {return "protocolIEs_t";}
48097                 using parent_t = ProtocolIE_Container<MobilityChangeRequest_IEs>;
48098
48099         };
48100         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
48101         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
48102         template<typename V> void decode(V& v)
48103         {
48104                 v(protocolIEs);
48105
48106         };
48107         template<typename V> void encode(V& v) const
48108         {
48109                 v(protocolIEs);
48110
48111         };
48112         void clear()
48113         {
48114                 protocolIEs.clear();
48115
48116         };
48117         private:
48118         protocolIEs_t   protocolIEs;
48119
48120 };
48121 /*
48122 PartialSuccessIndicator ::= ENUMERATED {
48123         partial-success-allowed,
48124 ...
48125 }
48126 */
48127
48128 struct PartialSuccessIndicator : asn::enumerated<1, 0, true>
48129 {
48130         static constexpr const char* name() {return "PartialSuccessIndicator";}
48131         using parent_t = asn::enumerated<1, 0, true>;
48132         typedef enum {
48133                 partial_success_allowed
48134         } index_t;
48135
48136 };
48137
48138 /*
48139 PrivateMessage-IEs X2AP-PRIVATE-IES ::= {
48140         ...
48141 }
48142 */
48143
48144 struct PrivateMessage_IEs
48145 {
48146         struct id_t : asn::fixedtypefield<X2AP_PRIVATE_IES::id_t, true>
48147         {
48148                 size_t get_index() const {return type;}
48149                 bool is_unknown() const { return type == 1; }
48150                 void clear() {type = 0;}
48151                 X2AP_PRIVATE_IES::id_t const& ref_value() const {return ref_nested();}
48152                 template<typename V>  bool decode(V& v)
48153                 {
48154                         clear();
48155                         if(!v(ref_nested())) return false;
48156                         { type = 1; return true;}
48157                         return false;
48158
48159                 }
48160                 template<typename V> bool encode(V& v) const
48161                 {
48162                         return v(ref_nested());
48163
48164                 }
48165                 protected:
48166                 template<typename V>  bool decode(size_t index, V& v)
48167                 {
48168                         clear();
48169                         switch(index)
48170                         {
48171                         case 1: type = 1; return v(ref_nested());
48172                         ref_nested().clear();
48173                         }
48174                         return false;
48175
48176                 }
48177                 template<typename V> bool encode(size_t index, V& v) const
48178                 {
48179                         if(index != type) {return false;} return v(ref_nested());
48180
48181                 }
48182                 private:
48183                 size_t type {0};
48184
48185         };
48186         struct criticality_t : asn::fixedtypefield<X2AP_PRIVATE_IES::criticality_t, true>
48187         {
48188                 size_t get_index() const {return type;}
48189                 bool is_unknown() const { return type == 1; }
48190                 void clear() {type = 0;}
48191                 X2AP_PRIVATE_IES::criticality_t const& ref_value() const {return ref_nested();}
48192                 template<typename V>  bool decode(V& v)
48193                 {
48194                         clear();
48195                         if(!v(ref_nested())) return false;
48196                         { type = 1; return true;}
48197                         return false;
48198
48199                 }
48200                 template<typename V> bool encode(V& v) const
48201                 {
48202                         return v(ref_nested());
48203
48204                 }
48205                 protected:
48206                 template<typename V>  bool decode(size_t index, V& v)
48207                 {
48208                         clear();
48209                         switch(index)
48210                         {
48211                         case 1: type = 1; return v(ref_nested());
48212                         ref_nested().clear();
48213                         }
48214                         return false;
48215
48216                 }
48217                 template<typename V> bool encode(size_t index, V& v) const
48218                 {
48219                         if(index != type) {return false;} return v(ref_nested());
48220
48221                 }
48222                 private:
48223                 size_t type {0};
48224
48225         };
48226         struct Value_t : asn::typefield<true>
48227         {
48228                 ~Value_t()      {clear();}
48229                 size_t get_index() const {return type;}
48230                 bool is_unknown() const { return type == 1; }
48231                 void clear()
48232                 {
48233                         type = 0; ref_nested().clear();
48234                 }
48235                 template<typename V> static inline void enumerate(V& v)
48236                 {
48237
48238                 }
48239                 protected:
48240                 template<typename V> bool decode(size_t index, V& v)
48241                 {
48242                         clear();
48243                         switch(index)
48244                         {
48245                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
48246                         }
48247                         return false;
48248
48249                 }
48250                 template<typename V> bool encode(size_t index, V& v) const
48251                 {
48252                         if(index != type) return false;
48253                         return false;
48254
48255                 }
48256                 private:
48257                 size_t type {0};
48258
48259         };
48260         struct presence_t : asn::fixedtypefield<X2AP_PRIVATE_IES::presence_t, true>
48261         {
48262                 size_t get_index() const {return type;}
48263                 bool is_unknown() const { return type == 1; }
48264                 void clear() {type = 0;}
48265                 X2AP_PRIVATE_IES::presence_t const& ref_value() const {return ref_nested();}
48266                 template<typename V>  bool decode(V& v)
48267                 {
48268                         clear();
48269                         if(!v(ref_nested())) return false;
48270                         { type = 1; return true;}
48271                         return false;
48272
48273                 }
48274                 template<typename V> bool encode(V& v) const
48275                 {
48276                         return v(ref_nested());
48277
48278                 }
48279                 protected:
48280                 template<typename V>  bool decode(size_t index, V& v)
48281                 {
48282                         clear();
48283                         switch(index)
48284                         {
48285                         case 1: type = 1; return v(ref_nested());
48286                         ref_nested().clear();
48287                         }
48288                         return false;
48289
48290                 }
48291                 template<typename V> bool encode(size_t index, V& v) const
48292                 {
48293                         if(index != type) {return false;} return v(ref_nested());
48294
48295                 }
48296                 private:
48297                 size_t type {0};
48298
48299         };
48300
48301 };
48302 /*
48303 PrivateMessage ::= SEQUENCE {
48304         privateIEs              PrivateIE-Container     {{PrivateMessage-IEs}},
48305         ...
48306 }
48307 */
48308
48309 struct PrivateMessage : asn::sequence<1, 0, true, 0>
48310 {
48311         static constexpr const char* name() {return "PrivateMessage";}
48312         using parent_t = asn::sequence<1, 0, true, 0>;
48313         struct privateIEs_t : PrivateIE_Container<PrivateMessage_IEs>
48314         {
48315                 static constexpr const char* name() {return "privateIEs_t";}
48316                 using parent_t = PrivateIE_Container<PrivateMessage_IEs>;
48317
48318         };
48319         privateIEs_t& ref_privateIEs() {return privateIEs;}
48320         privateIEs_t const& ref_privateIEs() const {return privateIEs;}
48321         template<typename V> void decode(V& v)
48322         {
48323                 v(privateIEs);
48324
48325         };
48326         template<typename V> void encode(V& v) const
48327         {
48328                 v(privateIEs);
48329
48330         };
48331         void clear()
48332         {
48333                 privateIEs.clear();
48334
48335         };
48336         private:
48337         privateIEs_t    privateIEs;
48338
48339 };
48340 /*
48341 RLFIndication-IEs X2AP-PROTOCOL-IES ::= {
48342         { ID id-FailureCellPCI                                                          CRITICALITY ignore      TYPE PCI                                                                                                                PRESENCE mandatory}|
48343         { ID id-Re-establishmentCellECGI                                        CRITICALITY ignore      TYPE ECGI                                                                                                               PRESENCE mandatory}|
48344         { ID id-FailureCellCRNTI                                                        CRITICALITY ignore      TYPE CRNTI                                                                                                              PRESENCE mandatory}|
48345         { ID id-ShortMAC-I                                                                      CRITICALITY ignore      TYPE ShortMAC-I                                                                                                 PRESENCE optional}|
48346         { ID id-UE-RLF-Report-Container                                         CRITICALITY ignore      TYPE UE-RLF-Report-Container                                                            PRESENCE optional}|
48347         { ID id-RRCConnSetupIndicator                                           CRITICALITY reject      TYPE RRCConnSetupIndicator                                                                      PRESENCE optional}|
48348         { ID id-RRCConnReestabIndicator                                         CRITICALITY ignore      TYPE RRCConnReestabIndicator                                                            PRESENCE optional}|
48349         { ID id-UE-RLF-Report-Container-for-extended-bands      CRITICALITY ignore      TYPE UE-RLF-Report-Container-for-extended-bands         PRESENCE optional},
48350         ...
48351 }
48352 */
48353
48354 struct RLFIndication_IEs
48355 {
48356         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
48357         {
48358                 size_t get_index() const {return type;}
48359                 bool is_unknown() const { return type == 9; }
48360                 void clear() {type = 0;}
48361                 void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=1;}
48362                 void select_id_Re_establishmentCellECGI() { set(id_Re_establishmentCellECGI); type=2;}
48363                 void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=3;}
48364                 void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
48365                 void select_id_UE_RLF_Report_Container() { set(id_UE_RLF_Report_Container); type=5;}
48366                 void select_id_RRCConnSetupIndicator() { set(id_RRCConnSetupIndicator); type=6;}
48367                 void select_id_RRCConnReestabIndicator() { set(id_RRCConnReestabIndicator); type=7;}
48368                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(id_UE_RLF_Report_Container_for_extended_bands); type=8;}
48369                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
48370                 template<typename V>  bool decode(V& v)
48371                 {
48372                         clear();
48373                         if(!v(ref_nested())) return false;
48374                         if(equal(id_FailureCellPCI)) { type = 1; return true; }
48375                         else if(equal(id_Re_establishmentCellECGI)) { type = 2; return true; }
48376                         else if(equal(id_FailureCellCRNTI)) { type = 3; return true; }
48377                         else if(equal(id_ShortMAC_I)) { type = 4; return true; }
48378                         else if(equal(id_UE_RLF_Report_Container)) { type = 5; return true; }
48379                         else if(equal(id_RRCConnSetupIndicator)) { type = 6; return true; }
48380                         else if(equal(id_RRCConnReestabIndicator)) { type = 7; return true; }
48381                         else if(equal(id_UE_RLF_Report_Container_for_extended_bands)) { type = 8; return true; }
48382                         else { type = 9; return true;}
48383                         return false;
48384
48385                 }
48386                 template<typename V> bool encode(V& v) const
48387                 {
48388                         return v(ref_nested());
48389
48390                 }
48391                 protected:
48392                 template<typename V>  bool decode(size_t index, V& v)
48393                 {
48394                         clear();
48395                         switch(index)
48396                         {
48397                         case 1: type = 1; if(v(ref_nested())) { return equal(id_FailureCellPCI);} return false;
48398                         case 2: type = 2; if(v(ref_nested())) { return equal(id_Re_establishmentCellECGI);} return false;
48399                         case 3: type = 3; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
48400                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
48401                         case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container);} return false;
48402                         case 6: type = 6; if(v(ref_nested())) { return equal(id_RRCConnSetupIndicator);} return false;
48403                         case 7: type = 7; if(v(ref_nested())) { return equal(id_RRCConnReestabIndicator);} return false;
48404                         case 8: type = 8; if(v(ref_nested())) { return equal(id_UE_RLF_Report_Container_for_extended_bands);} return false;
48405                         case 9: type = 9; return v(ref_nested());
48406                         ref_nested().clear();
48407                         }
48408                         return false;
48409
48410                 }
48411                 template<typename V> bool encode(size_t index, V& v) const
48412                 {
48413                         if(index != type) {return false;} return v(ref_nested());
48414
48415                 }
48416                 private:
48417                 size_t type {0};
48418
48419         };
48420         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
48421         {
48422                 size_t get_index() const {return type;}
48423                 bool is_unknown() const { return type == 9; }
48424                 void clear() {type = 0;}
48425                 void select_id_FailureCellPCI() { set(ignore); type=1;}
48426                 void select_id_Re_establishmentCellECGI() { set(ignore); type=2;}
48427                 void select_id_FailureCellCRNTI() { set(ignore); type=3;}
48428                 void select_id_ShortMAC_I() { set(ignore); type=4;}
48429                 void select_id_UE_RLF_Report_Container() { set(ignore); type=5;}
48430                 void select_id_RRCConnSetupIndicator() { set(reject); type=6;}
48431                 void select_id_RRCConnReestabIndicator() { set(ignore); type=7;}
48432                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(ignore); type=8;}
48433                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
48434                 template<typename V>  bool decode(V& v)
48435                 {
48436                         clear();
48437                         if(!v(ref_nested())) return false;
48438                         if(equal(ignore)) { type = 1; return true; }
48439                         else if(equal(ignore)) { type = 2; return true; }
48440                         else if(equal(ignore)) { type = 3; return true; }
48441                         else if(equal(ignore)) { type = 4; return true; }
48442                         else if(equal(ignore)) { type = 5; return true; }
48443                         else if(equal(reject)) { type = 6; return true; }
48444                         else if(equal(ignore)) { type = 7; return true; }
48445                         else if(equal(ignore)) { type = 8; return true; }
48446                         else { type = 9; return true;}
48447                         return false;
48448
48449                 }
48450                 template<typename V> bool encode(V& v) const
48451                 {
48452                         return v(ref_nested());
48453
48454                 }
48455                 protected:
48456                 template<typename V>  bool decode(size_t index, V& v)
48457                 {
48458                         clear();
48459                         switch(index)
48460                         {
48461                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
48462                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
48463                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
48464                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
48465                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
48466                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
48467                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
48468                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
48469                         case 9: type = 9; return v(ref_nested());
48470                         ref_nested().clear();
48471                         }
48472                         return false;
48473
48474                 }
48475                 template<typename V> bool encode(size_t index, V& v) const
48476                 {
48477                         if(index != type) {return false;} return v(ref_nested());
48478
48479                 }
48480                 private:
48481                 size_t type {0};
48482
48483         };
48484         struct Value_t : asn::typefield<true>
48485         {
48486                 ~Value_t()      {clear();}
48487                 size_t get_index() const {return type;}
48488                 PCI& select_id_FailureCellPCI() { return set<PCI>(1); }
48489                 PCI const* get_id_FailureCellPCI() const { return get<PCI>(1); }
48490                 ECGI& select_id_Re_establishmentCellECGI() { return set<ECGI>(2); }
48491                 ECGI const* get_id_Re_establishmentCellECGI() const { return get<ECGI>(2); }
48492                 CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(3); }
48493                 CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(3); }
48494                 ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
48495                 ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
48496                 UE_RLF_Report_Container& select_id_UE_RLF_Report_Container() { return set<UE_RLF_Report_Container>(5); }
48497                 UE_RLF_Report_Container const* get_id_UE_RLF_Report_Container() const { return get<UE_RLF_Report_Container>(5); }
48498                 RRCConnSetupIndicator& select_id_RRCConnSetupIndicator() { return set<RRCConnSetupIndicator>(6); }
48499                 RRCConnSetupIndicator const* get_id_RRCConnSetupIndicator() const { return get<RRCConnSetupIndicator>(6); }
48500                 RRCConnReestabIndicator& select_id_RRCConnReestabIndicator() { return set<RRCConnReestabIndicator>(7); }
48501                 RRCConnReestabIndicator const* get_id_RRCConnReestabIndicator() const { return get<RRCConnReestabIndicator>(7); }
48502                 UE_RLF_Report_Container_for_extended_bands& select_id_UE_RLF_Report_Container_for_extended_bands() { return set<UE_RLF_Report_Container_for_extended_bands>(8); }
48503                 UE_RLF_Report_Container_for_extended_bands const* get_id_UE_RLF_Report_Container_for_extended_bands() const { return get<UE_RLF_Report_Container_for_extended_bands>(8); }
48504                 bool is_unknown() const { return type == 9; }
48505                 void clear()
48506                 {
48507                         switch(type)
48508                         {
48509                         case 1: var.destroy<PCI>(); break;
48510                         case 2: var.destroy<ECGI>(); break;
48511                         case 3: var.destroy<CRNTI>(); break;
48512                         case 4: var.destroy<ShortMAC_I>(); break;
48513                         case 5: var.destroy<UE_RLF_Report_Container>(); break;
48514                         case 6: var.destroy<RRCConnSetupIndicator>(); break;
48515                         case 7: var.destroy<RRCConnReestabIndicator>(); break;
48516                         case 8: var.destroy<UE_RLF_Report_Container_for_extended_bands>(); break;
48517                         }
48518                         type = 0; ref_nested().clear();
48519                 }
48520                 template<typename V> static inline void enumerate(V& v)
48521                 {
48522                         v.template operator()<PCI>(1);
48523                         v.template operator()<ECGI>(2);
48524                         v.template operator()<CRNTI>(3);
48525                         v.template operator()<ShortMAC_I>(4);
48526                         v.template operator()<UE_RLF_Report_Container>(5);
48527                         v.template operator()<RRCConnSetupIndicator>(6);
48528                         v.template operator()<RRCConnReestabIndicator>(7);
48529                         v.template operator()<UE_RLF_Report_Container_for_extended_bands>(8);
48530
48531                 }
48532                 protected:
48533                 template<typename V> bool decode(size_t index, V& v)
48534                 {
48535                         clear();
48536                         switch(index)
48537                         {
48538                         case 1: v(select_id_FailureCellPCI()); return true;
48539                         case 2: v(select_id_Re_establishmentCellECGI()); return true;
48540                         case 3: v(select_id_FailureCellCRNTI()); return true;
48541                         case 4: v(select_id_ShortMAC_I()); return true;
48542                         case 5: v(select_id_UE_RLF_Report_Container()); return true;
48543                         case 6: v(select_id_RRCConnSetupIndicator()); return true;
48544                         case 7: v(select_id_RRCConnReestabIndicator()); return true;
48545                         case 8: v(select_id_UE_RLF_Report_Container_for_extended_bands()); return true;
48546                         case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
48547                         }
48548                         return false;
48549
48550                 }
48551                 template<typename V> bool encode(size_t index, V& v) const
48552                 {
48553                         if(index != type) return false;
48554                         switch(type)
48555                         {
48556                         case 1: v(var.as<PCI>()); return true;
48557                         case 2: v(var.as<ECGI>()); return true;
48558                         case 3: v(var.as<CRNTI>()); return true;
48559                         case 4: v(var.as<ShortMAC_I>()); return true;
48560                         case 5: v(var.as<UE_RLF_Report_Container>()); return true;
48561                         case 6: v(var.as<RRCConnSetupIndicator>()); return true;
48562                         case 7: v(var.as<RRCConnReestabIndicator>()); return true;
48563                         case 8: v(var.as<UE_RLF_Report_Container_for_extended_bands>()); return true;
48564                         }
48565                         return false;
48566
48567                 }
48568                 private:
48569                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
48570                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
48571                 union union_type
48572                 {
48573                         char dummy1[sizeof(CRNTI)];
48574                         char dummy2[sizeof(ECGI)];
48575                         char dummy3[sizeof(PCI)];
48576                         char dummy4[sizeof(RRCConnReestabIndicator)];
48577                         char dummy5[sizeof(RRCConnSetupIndicator)];
48578                         char dummy6[sizeof(ShortMAC_I)];
48579                         char dummy7[sizeof(UE_RLF_Report_Container)];
48580                         char dummy8[sizeof(UE_RLF_Report_Container_for_extended_bands)];
48581
48582                 };
48583                 asn::variant<sizeof(union_type)> var;
48584                 size_t type {0};
48585
48586         };
48587         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
48588         {
48589                 size_t get_index() const {return type;}
48590                 bool is_unknown() const { return type == 9; }
48591                 void clear() {type = 0;}
48592                 void select_id_FailureCellPCI() { set(mandatory); type=1;}
48593                 void select_id_Re_establishmentCellECGI() { set(mandatory); type=2;}
48594                 void select_id_FailureCellCRNTI() { set(mandatory); type=3;}
48595                 void select_id_ShortMAC_I() { set(optional); type=4;}
48596                 void select_id_UE_RLF_Report_Container() { set(optional); type=5;}
48597                 void select_id_RRCConnSetupIndicator() { set(optional); type=6;}
48598                 void select_id_RRCConnReestabIndicator() { set(optional); type=7;}
48599                 void select_id_UE_RLF_Report_Container_for_extended_bands() { set(optional); type=8;}
48600                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
48601                 template<typename V>  bool decode(V& v)
48602                 {
48603                         clear();
48604                         if(!v(ref_nested())) return false;
48605                         if(equal(mandatory)) { type = 1; return true; }
48606                         else if(equal(mandatory)) { type = 2; return true; }
48607                         else if(equal(mandatory)) { type = 3; return true; }
48608                         else if(equal(optional)) { type = 4; return true; }
48609                         else if(equal(optional)) { type = 5; return true; }
48610                         else if(equal(optional)) { type = 6; return true; }
48611                         else if(equal(optional)) { type = 7; return true; }
48612                         else if(equal(optional)) { type = 8; return true; }
48613                         else { type = 9; return true;}
48614                         return false;
48615
48616                 }
48617                 template<typename V> bool encode(V& v) const
48618                 {
48619                         return v(ref_nested());
48620
48621                 }
48622                 protected:
48623                 template<typename V>  bool decode(size_t index, V& v)
48624                 {
48625                         clear();
48626                         switch(index)
48627                         {
48628                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
48629                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
48630                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
48631                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
48632                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
48633                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
48634                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
48635                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
48636                         case 9: type = 9; return v(ref_nested());
48637                         ref_nested().clear();
48638                         }
48639                         return false;
48640
48641                 }
48642                 template<typename V> bool encode(size_t index, V& v) const
48643                 {
48644                         if(index != type) {return false;} return v(ref_nested());
48645
48646                 }
48647                 private:
48648                 size_t type {0};
48649
48650         };
48651
48652 };
48653 /*
48654 RLFIndication ::= SEQUENCE {
48655         protocolIEs             ProtocolIE-Container    {{RLFIndication-IEs}},
48656         ...
48657 }
48658 */
48659
48660 struct RLFIndication : asn::sequence<1, 0, true, 0>
48661 {
48662         static constexpr const char* name() {return "RLFIndication";}
48663         using parent_t = asn::sequence<1, 0, true, 0>;
48664         struct protocolIEs_t : ProtocolIE_Container<RLFIndication_IEs>
48665         {
48666                 static constexpr const char* name() {return "protocolIEs_t";}
48667                 using parent_t = ProtocolIE_Container<RLFIndication_IEs>;
48668
48669         };
48670         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
48671         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
48672         template<typename V> void decode(V& v)
48673         {
48674                 v(protocolIEs);
48675
48676         };
48677         template<typename V> void encode(V& v) const
48678         {
48679                 v(protocolIEs);
48680
48681         };
48682         void clear()
48683         {
48684                 protocolIEs.clear();
48685
48686         };
48687         private:
48688         protocolIEs_t   protocolIEs;
48689
48690 };
48691 /*
48692 RNL-Header-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
48693         ...
48694 }
48695 */
48696
48697 struct RNL_Header_Item_ExtIEs
48698 {
48699         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
48700         {
48701                 size_t get_index() const {return type;}
48702                 bool is_unknown() const { return type == 1; }
48703                 void clear() {type = 0;}
48704                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
48705                 template<typename V>  bool decode(V& v)
48706                 {
48707                         clear();
48708                         if(!v(ref_nested())) return false;
48709                         { type = 1; return true;}
48710                         return false;
48711
48712                 }
48713                 template<typename V> bool encode(V& v) const
48714                 {
48715                         return v(ref_nested());
48716
48717                 }
48718                 protected:
48719                 template<typename V>  bool decode(size_t index, V& v)
48720                 {
48721                         clear();
48722                         switch(index)
48723                         {
48724                         case 1: type = 1; return v(ref_nested());
48725                         ref_nested().clear();
48726                         }
48727                         return false;
48728
48729                 }
48730                 template<typename V> bool encode(size_t index, V& v) const
48731                 {
48732                         if(index != type) {return false;} return v(ref_nested());
48733
48734                 }
48735                 private:
48736                 size_t type {0};
48737
48738         };
48739         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
48740         {
48741                 size_t get_index() const {return type;}
48742                 bool is_unknown() const { return type == 1; }
48743                 void clear() {type = 0;}
48744                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
48745                 template<typename V>  bool decode(V& v)
48746                 {
48747                         clear();
48748                         if(!v(ref_nested())) return false;
48749                         { type = 1; return true;}
48750                         return false;
48751
48752                 }
48753                 template<typename V> bool encode(V& v) const
48754                 {
48755                         return v(ref_nested());
48756
48757                 }
48758                 protected:
48759                 template<typename V>  bool decode(size_t index, V& v)
48760                 {
48761                         clear();
48762                         switch(index)
48763                         {
48764                         case 1: type = 1; return v(ref_nested());
48765                         ref_nested().clear();
48766                         }
48767                         return false;
48768
48769                 }
48770                 template<typename V> bool encode(size_t index, V& v) const
48771                 {
48772                         if(index != type) {return false;} return v(ref_nested());
48773
48774                 }
48775                 private:
48776                 size_t type {0};
48777
48778         };
48779         struct Extension_t : asn::typefield<true>
48780         {
48781                 ~Extension_t()  {clear();}
48782                 size_t get_index() const {return type;}
48783                 bool is_unknown() const { return type == 1; }
48784                 void clear()
48785                 {
48786                         type = 0; ref_nested().clear();
48787                 }
48788                 template<typename V> static inline void enumerate(V& v)
48789                 {
48790
48791                 }
48792                 protected:
48793                 template<typename V> bool decode(size_t index, V& v)
48794                 {
48795                         clear();
48796                         switch(index)
48797                         {
48798                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
48799                         }
48800                         return false;
48801
48802                 }
48803                 template<typename V> bool encode(size_t index, V& v) const
48804                 {
48805                         if(index != type) return false;
48806                         return false;
48807
48808                 }
48809                 private:
48810                 size_t type {0};
48811
48812         };
48813         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
48814         {
48815                 size_t get_index() const {return type;}
48816                 bool is_unknown() const { return type == 1; }
48817                 void clear() {type = 0;}
48818                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
48819                 template<typename V>  bool decode(V& v)
48820                 {
48821                         clear();
48822                         if(!v(ref_nested())) return false;
48823                         { type = 1; return true;}
48824                         return false;
48825
48826                 }
48827                 template<typename V> bool encode(V& v) const
48828                 {
48829                         return v(ref_nested());
48830
48831                 }
48832                 protected:
48833                 template<typename V>  bool decode(size_t index, V& v)
48834                 {
48835                         clear();
48836                         switch(index)
48837                         {
48838                         case 1: type = 1; return v(ref_nested());
48839                         ref_nested().clear();
48840                         }
48841                         return false;
48842
48843                 }
48844                 template<typename V> bool encode(size_t index, V& v) const
48845                 {
48846                         if(index != type) {return false;} return v(ref_nested());
48847
48848                 }
48849                 private:
48850                 size_t type {0};
48851
48852         };
48853
48854 };
48855 /*
48856 RNL-Header ::= SEQUENCE {
48857         source-GlobalENB-ID     GlobalENB-ID,
48858         target-GlobalENB-ID     GlobalENB-ID    OPTIONAL,
48859         iE-Extensions                                           ProtocolExtensionContainer { {RNL-Header-Item-ExtIEs} } OPTIONAL,
48860         ...
48861 }
48862 */
48863
48864 struct RNL_Header : asn::sequence<3, 0, true, 2>
48865 {
48866         static constexpr const char* name() {return "RNL-Header";}
48867         using parent_t = asn::sequence<3, 0, true, 2>;
48868         struct source_GlobalENB_ID_t : GlobalENB_ID
48869         {
48870                 static constexpr const char* name() {return "source_GlobalENB_ID_t";}
48871                 using parent_t = GlobalENB_ID;
48872
48873         };
48874         source_GlobalENB_ID_t& ref_source_GlobalENB_ID() {return source_GlobalENB_ID;}
48875         source_GlobalENB_ID_t const& ref_source_GlobalENB_ID() const {return source_GlobalENB_ID;}
48876         struct target_GlobalENB_ID_t : GlobalENB_ID
48877         {
48878                 static constexpr const char* name() {return "target_GlobalENB_ID_t";}
48879                 using parent_t = GlobalENB_ID;
48880                 static constexpr bool optional = true;
48881
48882         };
48883         target_GlobalENB_ID_t& set_target_GlobalENB_ID() { target_GlobalENB_ID.setpresent(true); return target_GlobalENB_ID;}
48884         target_GlobalENB_ID_t const* get_target_GlobalENB_ID() const {return target_GlobalENB_ID.is_valid() ? &target_GlobalENB_ID : nullptr;}
48885         struct iE_Extensions_t : ProtocolExtensionContainer<RNL_Header_Item_ExtIEs>
48886         {
48887                 static constexpr const char* name() {return "iE_Extensions_t";}
48888                 using parent_t = ProtocolExtensionContainer<RNL_Header_Item_ExtIEs>;
48889                 static constexpr bool optional = true;
48890
48891         };
48892         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
48893         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
48894         template<typename V> void decode(V& v)
48895         {
48896                 v(source_GlobalENB_ID);
48897                 v(target_GlobalENB_ID);
48898                 v(iE_Extensions);
48899
48900         };
48901         template<typename V> void encode(V& v) const
48902         {
48903                 v(source_GlobalENB_ID);
48904                 v(target_GlobalENB_ID);
48905                 v(iE_Extensions);
48906
48907         };
48908         void clear()
48909         {
48910                 source_GlobalENB_ID.clear();
48911                 target_GlobalENB_ID.clear();
48912                 iE_Extensions.clear();
48913
48914         };
48915         private:
48916         source_GlobalENB_ID_t   source_GlobalENB_ID;
48917         target_GlobalENB_ID_t   target_GlobalENB_ID;
48918         iE_Extensions_t iE_Extensions;
48919
48920 };
48921 /*
48922 RRCTransfer-IEs X2AP-PROTOCOL-IES ::= {
48923         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
48924         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                            PRESENCE mandatory}|
48925         { ID id-SplitSRB                                                                CRITICALITY reject      TYPE SplitSRB                                   PRESENCE optional}|
48926         { ID id-UENRMeasurement                                         CRITICALITY reject      TYPE UENRMeasurement                            PRESENCE optional}|
48927         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
48928         ...
48929 }
48930 */
48931
48932 struct RRCTransfer_IEs
48933 {
48934         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
48935         {
48936                 size_t get_index() const {return type;}
48937                 bool is_unknown() const { return type == 6; }
48938                 void clear() {type = 0;}
48939                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
48940                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
48941                 void select_id_SplitSRB() { set(id_SplitSRB); type=3;}
48942                 void select_id_UENRMeasurement() { set(id_UENRMeasurement); type=4;}
48943                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
48944                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
48945                 template<typename V>  bool decode(V& v)
48946                 {
48947                         clear();
48948                         if(!v(ref_nested())) return false;
48949                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
48950                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
48951                         else if(equal(id_SplitSRB)) { type = 3; return true; }
48952                         else if(equal(id_UENRMeasurement)) { type = 4; return true; }
48953                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
48954                         else { type = 6; return true;}
48955                         return false;
48956
48957                 }
48958                 template<typename V> bool encode(V& v) const
48959                 {
48960                         return v(ref_nested());
48961
48962                 }
48963                 protected:
48964                 template<typename V>  bool decode(size_t index, V& v)
48965                 {
48966                         clear();
48967                         switch(index)
48968                         {
48969                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
48970                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
48971                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SplitSRB);} return false;
48972                         case 4: type = 4; if(v(ref_nested())) { return equal(id_UENRMeasurement);} return false;
48973                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
48974                         case 6: type = 6; return v(ref_nested());
48975                         ref_nested().clear();
48976                         }
48977                         return false;
48978
48979                 }
48980                 template<typename V> bool encode(size_t index, V& v) const
48981                 {
48982                         if(index != type) {return false;} return v(ref_nested());
48983
48984                 }
48985                 private:
48986                 size_t type {0};
48987
48988         };
48989         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
48990         {
48991                 size_t get_index() const {return type;}
48992                 bool is_unknown() const { return type == 6; }
48993                 void clear() {type = 0;}
48994                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
48995                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
48996                 void select_id_SplitSRB() { set(reject); type=3;}
48997                 void select_id_UENRMeasurement() { set(reject); type=4;}
48998                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
48999                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49000                 template<typename V>  bool decode(V& v)
49001                 {
49002                         clear();
49003                         if(!v(ref_nested())) return false;
49004                         if(equal(reject)) { type = 1; return true; }
49005                         else if(equal(reject)) { type = 2; return true; }
49006                         else if(equal(reject)) { type = 3; return true; }
49007                         else if(equal(reject)) { type = 4; return true; }
49008                         else if(equal(reject)) { type = 5; return true; }
49009                         else { type = 6; return true;}
49010                         return false;
49011
49012                 }
49013                 template<typename V> bool encode(V& v) const
49014                 {
49015                         return v(ref_nested());
49016
49017                 }
49018                 protected:
49019                 template<typename V>  bool decode(size_t index, V& v)
49020                 {
49021                         clear();
49022                         switch(index)
49023                         {
49024                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
49025                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
49026                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
49027                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
49028                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
49029                         case 6: type = 6; return v(ref_nested());
49030                         ref_nested().clear();
49031                         }
49032                         return false;
49033
49034                 }
49035                 template<typename V> bool encode(size_t index, V& v) const
49036                 {
49037                         if(index != type) {return false;} return v(ref_nested());
49038
49039                 }
49040                 private:
49041                 size_t type {0};
49042
49043         };
49044         struct Value_t : asn::typefield<true>
49045         {
49046                 ~Value_t()      {clear();}
49047                 size_t get_index() const {return type;}
49048                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
49049                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
49050                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
49051                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
49052                 SplitSRB& select_id_SplitSRB() { return set<SplitSRB>(3); }
49053                 SplitSRB const* get_id_SplitSRB() const { return get<SplitSRB>(3); }
49054                 UENRMeasurement& select_id_UENRMeasurement() { return set<UENRMeasurement>(4); }
49055                 UENRMeasurement const* get_id_UENRMeasurement() const { return get<UENRMeasurement>(4); }
49056                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
49057                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
49058                 bool is_unknown() const { return type == 6; }
49059                 void clear()
49060                 {
49061                         switch(type)
49062                         {
49063                         case 1: var.destroy<UE_X2AP_ID>(); break;
49064                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
49065                         case 3: var.destroy<SplitSRB>(); break;
49066                         case 4: var.destroy<UENRMeasurement>(); break;
49067                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
49068                         }
49069                         type = 0; ref_nested().clear();
49070                 }
49071                 template<typename V> static inline void enumerate(V& v)
49072                 {
49073                         v.template operator()<UE_X2AP_ID>(1);
49074                         v.template operator()<SgNB_UE_X2AP_ID>(2);
49075                         v.template operator()<SplitSRB>(3);
49076                         v.template operator()<UENRMeasurement>(4);
49077                         v.template operator()<UE_X2AP_ID_Extension>(5);
49078
49079                 }
49080                 protected:
49081                 template<typename V> bool decode(size_t index, V& v)
49082                 {
49083                         clear();
49084                         switch(index)
49085                         {
49086                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
49087                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
49088                         case 3: v(select_id_SplitSRB()); return true;
49089                         case 4: v(select_id_UENRMeasurement()); return true;
49090                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
49091                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
49092                         }
49093                         return false;
49094
49095                 }
49096                 template<typename V> bool encode(size_t index, V& v) const
49097                 {
49098                         if(index != type) return false;
49099                         switch(type)
49100                         {
49101                         case 1: v(var.as<UE_X2AP_ID>()); return true;
49102                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
49103                         case 3: v(var.as<SplitSRB>()); return true;
49104                         case 4: v(var.as<UENRMeasurement>()); return true;
49105                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
49106                         }
49107                         return false;
49108
49109                 }
49110                 private:
49111                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49112                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49113                 union union_type
49114                 {
49115                         char dummy1[sizeof(SgNB_UE_X2AP_ID)];
49116                         char dummy2[sizeof(SplitSRB)];
49117                         char dummy3[sizeof(UENRMeasurement)];
49118                         char dummy4[sizeof(UE_X2AP_ID)];
49119                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
49120
49121                 };
49122                 asn::variant<sizeof(union_type)> var;
49123                 size_t type {0};
49124
49125         };
49126         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49127         {
49128                 size_t get_index() const {return type;}
49129                 bool is_unknown() const { return type == 6; }
49130                 void clear() {type = 0;}
49131                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
49132                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
49133                 void select_id_SplitSRB() { set(optional); type=3;}
49134                 void select_id_UENRMeasurement() { set(optional); type=4;}
49135                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
49136                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49137                 template<typename V>  bool decode(V& v)
49138                 {
49139                         clear();
49140                         if(!v(ref_nested())) return false;
49141                         if(equal(mandatory)) { type = 1; return true; }
49142                         else if(equal(mandatory)) { type = 2; return true; }
49143                         else if(equal(optional)) { type = 3; return true; }
49144                         else if(equal(optional)) { type = 4; return true; }
49145                         else if(equal(optional)) { type = 5; return true; }
49146                         else { type = 6; return true;}
49147                         return false;
49148
49149                 }
49150                 template<typename V> bool encode(V& v) const
49151                 {
49152                         return v(ref_nested());
49153
49154                 }
49155                 protected:
49156                 template<typename V>  bool decode(size_t index, V& v)
49157                 {
49158                         clear();
49159                         switch(index)
49160                         {
49161                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49162                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
49163                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
49164                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
49165                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
49166                         case 6: type = 6; return v(ref_nested());
49167                         ref_nested().clear();
49168                         }
49169                         return false;
49170
49171                 }
49172                 template<typename V> bool encode(size_t index, V& v) const
49173                 {
49174                         if(index != type) {return false;} return v(ref_nested());
49175
49176                 }
49177                 private:
49178                 size_t type {0};
49179
49180         };
49181
49182 };
49183 /*
49184 RRCTransfer ::= SEQUENCE {
49185         protocolIEs             ProtocolIE-Container            {{RRCTransfer-IEs}},
49186         ...
49187 }
49188 */
49189
49190 struct RRCTransfer : asn::sequence<1, 0, true, 0>
49191 {
49192         static constexpr const char* name() {return "RRCTransfer";}
49193         using parent_t = asn::sequence<1, 0, true, 0>;
49194         struct protocolIEs_t : ProtocolIE_Container<RRCTransfer_IEs>
49195         {
49196                 static constexpr const char* name() {return "protocolIEs_t";}
49197                 using parent_t = ProtocolIE_Container<RRCTransfer_IEs>;
49198
49199         };
49200         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49201         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49202         template<typename V> void decode(V& v)
49203         {
49204                 v(protocolIEs);
49205
49206         };
49207         template<typename V> void encode(V& v) const
49208         {
49209                 v(protocolIEs);
49210
49211         };
49212         void clear()
49213         {
49214                 protocolIEs.clear();
49215
49216         };
49217         private:
49218         protocolIEs_t   protocolIEs;
49219
49220 };
49221 /*
49222 ReportingPeriodicity ::= ENUMERATED {
49223         one-thousand-ms,
49224         two-thousand-ms,
49225         five-thousand-ms,
49226         ten-thousand-ms,
49227 ...
49228 }
49229 */
49230
49231 struct ReportingPeriodicity : asn::enumerated<4, 0, true>
49232 {
49233         static constexpr const char* name() {return "ReportingPeriodicity";}
49234         using parent_t = asn::enumerated<4, 0, true>;
49235         typedef enum {
49236                 one_thousand_ms
49237                 ,two_thousand_ms
49238                 ,five_thousand_ms
49239                 ,ten_thousand_ms
49240         } index_t;
49241
49242 };
49243
49244 /*
49245 ResetRequest-IEs X2AP-PROTOCOL-IES ::= {
49246         { ID id-Cause                           CRITICALITY ignore      TYPE Cause                              PRESENCE mandatory},
49247         ...
49248 }
49249 */
49250
49251 struct ResetRequest_IEs
49252 {
49253         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49254         {
49255                 size_t get_index() const {return type;}
49256                 bool is_unknown() const { return type == 2; }
49257                 void clear() {type = 0;}
49258                 void select_id_Cause() { set(id_Cause); type=1;}
49259                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49260                 template<typename V>  bool decode(V& v)
49261                 {
49262                         clear();
49263                         if(!v(ref_nested())) return false;
49264                         if(equal(id_Cause)) { type = 1; return true; }
49265                         else { type = 2; return true;}
49266                         return false;
49267
49268                 }
49269                 template<typename V> bool encode(V& v) const
49270                 {
49271                         return v(ref_nested());
49272
49273                 }
49274                 protected:
49275                 template<typename V>  bool decode(size_t index, V& v)
49276                 {
49277                         clear();
49278                         switch(index)
49279                         {
49280                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
49281                         case 2: type = 2; return v(ref_nested());
49282                         ref_nested().clear();
49283                         }
49284                         return false;
49285
49286                 }
49287                 template<typename V> bool encode(size_t index, V& v) const
49288                 {
49289                         if(index != type) {return false;} return v(ref_nested());
49290
49291                 }
49292                 private:
49293                 size_t type {0};
49294
49295         };
49296         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49297         {
49298                 size_t get_index() const {return type;}
49299                 bool is_unknown() const { return type == 2; }
49300                 void clear() {type = 0;}
49301                 void select_id_Cause() { set(ignore); type=1;}
49302                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49303                 template<typename V>  bool decode(V& v)
49304                 {
49305                         clear();
49306                         if(!v(ref_nested())) return false;
49307                         if(equal(ignore)) { type = 1; return true; }
49308                         else { type = 2; return true;}
49309                         return false;
49310
49311                 }
49312                 template<typename V> bool encode(V& v) const
49313                 {
49314                         return v(ref_nested());
49315
49316                 }
49317                 protected:
49318                 template<typename V>  bool decode(size_t index, V& v)
49319                 {
49320                         clear();
49321                         switch(index)
49322                         {
49323                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
49324                         case 2: type = 2; return v(ref_nested());
49325                         ref_nested().clear();
49326                         }
49327                         return false;
49328
49329                 }
49330                 template<typename V> bool encode(size_t index, V& v) const
49331                 {
49332                         if(index != type) {return false;} return v(ref_nested());
49333
49334                 }
49335                 private:
49336                 size_t type {0};
49337
49338         };
49339         struct Value_t : asn::typefield<true>
49340         {
49341                 ~Value_t()      {clear();}
49342                 size_t get_index() const {return type;}
49343                 Cause& select_id_Cause() { return set<Cause>(1); }
49344                 Cause const* get_id_Cause() const { return get<Cause>(1); }
49345                 bool is_unknown() const { return type == 2; }
49346                 void clear()
49347                 {
49348                         switch(type)
49349                         {
49350                         case 1: var.destroy<Cause>(); break;
49351                         }
49352                         type = 0; ref_nested().clear();
49353                 }
49354                 template<typename V> static inline void enumerate(V& v)
49355                 {
49356                         v.template operator()<Cause>(1);
49357
49358                 }
49359                 protected:
49360                 template<typename V> bool decode(size_t index, V& v)
49361                 {
49362                         clear();
49363                         switch(index)
49364                         {
49365                         case 1: v(select_id_Cause()); return true;
49366                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
49367                         }
49368                         return false;
49369
49370                 }
49371                 template<typename V> bool encode(size_t index, V& v) const
49372                 {
49373                         if(index != type) return false;
49374                         switch(type)
49375                         {
49376                         case 1: v(var.as<Cause>()); return true;
49377                         }
49378                         return false;
49379
49380                 }
49381                 private:
49382                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49383                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49384                 union union_type
49385                 {
49386                         char dummy1[sizeof(Cause)];
49387
49388                 };
49389                 asn::variant<sizeof(union_type)> var;
49390                 size_t type {0};
49391
49392         };
49393         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49394         {
49395                 size_t get_index() const {return type;}
49396                 bool is_unknown() const { return type == 2; }
49397                 void clear() {type = 0;}
49398                 void select_id_Cause() { set(mandatory); type=1;}
49399                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49400                 template<typename V>  bool decode(V& v)
49401                 {
49402                         clear();
49403                         if(!v(ref_nested())) return false;
49404                         if(equal(mandatory)) { type = 1; return true; }
49405                         else { type = 2; return true;}
49406                         return false;
49407
49408                 }
49409                 template<typename V> bool encode(V& v) const
49410                 {
49411                         return v(ref_nested());
49412
49413                 }
49414                 protected:
49415                 template<typename V>  bool decode(size_t index, V& v)
49416                 {
49417                         clear();
49418                         switch(index)
49419                         {
49420                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49421                         case 2: type = 2; return v(ref_nested());
49422                         ref_nested().clear();
49423                         }
49424                         return false;
49425
49426                 }
49427                 template<typename V> bool encode(size_t index, V& v) const
49428                 {
49429                         if(index != type) {return false;} return v(ref_nested());
49430
49431                 }
49432                 private:
49433                 size_t type {0};
49434
49435         };
49436
49437 };
49438 /*
49439 ResetRequest ::= SEQUENCE {
49440         protocolIEs             ProtocolIE-Container    {{ResetRequest-IEs}},
49441         ...
49442 }
49443 */
49444
49445 struct ResetRequest : asn::sequence<1, 0, true, 0>
49446 {
49447         static constexpr const char* name() {return "ResetRequest";}
49448         using parent_t = asn::sequence<1, 0, true, 0>;
49449         struct protocolIEs_t : ProtocolIE_Container<ResetRequest_IEs>
49450         {
49451                 static constexpr const char* name() {return "protocolIEs_t";}
49452                 using parent_t = ProtocolIE_Container<ResetRequest_IEs>;
49453
49454         };
49455         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49456         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49457         template<typename V> void decode(V& v)
49458         {
49459                 v(protocolIEs);
49460
49461         };
49462         template<typename V> void encode(V& v) const
49463         {
49464                 v(protocolIEs);
49465
49466         };
49467         void clear()
49468         {
49469                 protocolIEs.clear();
49470
49471         };
49472         private:
49473         protocolIEs_t   protocolIEs;
49474
49475 };
49476 /*
49477 ResetResponse-IEs X2AP-PROTOCOL-IES ::= {
49478         { ID id-CriticalityDiagnostics  CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional },
49479         ...
49480 }
49481 */
49482
49483 struct ResetResponse_IEs
49484 {
49485         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49486         {
49487                 size_t get_index() const {return type;}
49488                 bool is_unknown() const { return type == 2; }
49489                 void clear() {type = 0;}
49490                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=1;}
49491                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49492                 template<typename V>  bool decode(V& v)
49493                 {
49494                         clear();
49495                         if(!v(ref_nested())) return false;
49496                         if(equal(id_CriticalityDiagnostics)) { type = 1; return true; }
49497                         else { type = 2; return true;}
49498                         return false;
49499
49500                 }
49501                 template<typename V> bool encode(V& v) const
49502                 {
49503                         return v(ref_nested());
49504
49505                 }
49506                 protected:
49507                 template<typename V>  bool decode(size_t index, V& v)
49508                 {
49509                         clear();
49510                         switch(index)
49511                         {
49512                         case 1: type = 1; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
49513                         case 2: type = 2; return v(ref_nested());
49514                         ref_nested().clear();
49515                         }
49516                         return false;
49517
49518                 }
49519                 template<typename V> bool encode(size_t index, V& v) const
49520                 {
49521                         if(index != type) {return false;} return v(ref_nested());
49522
49523                 }
49524                 private:
49525                 size_t type {0};
49526
49527         };
49528         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49529         {
49530                 size_t get_index() const {return type;}
49531                 bool is_unknown() const { return type == 2; }
49532                 void clear() {type = 0;}
49533                 void select_id_CriticalityDiagnostics() { set(ignore); type=1;}
49534                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49535                 template<typename V>  bool decode(V& v)
49536                 {
49537                         clear();
49538                         if(!v(ref_nested())) return false;
49539                         if(equal(ignore)) { type = 1; return true; }
49540                         else { type = 2; return true;}
49541                         return false;
49542
49543                 }
49544                 template<typename V> bool encode(V& v) const
49545                 {
49546                         return v(ref_nested());
49547
49548                 }
49549                 protected:
49550                 template<typename V>  bool decode(size_t index, V& v)
49551                 {
49552                         clear();
49553                         switch(index)
49554                         {
49555                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
49556                         case 2: type = 2; return v(ref_nested());
49557                         ref_nested().clear();
49558                         }
49559                         return false;
49560
49561                 }
49562                 template<typename V> bool encode(size_t index, V& v) const
49563                 {
49564                         if(index != type) {return false;} return v(ref_nested());
49565
49566                 }
49567                 private:
49568                 size_t type {0};
49569
49570         };
49571         struct Value_t : asn::typefield<true>
49572         {
49573                 ~Value_t()      {clear();}
49574                 size_t get_index() const {return type;}
49575                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(1); }
49576                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(1); }
49577                 bool is_unknown() const { return type == 2; }
49578                 void clear()
49579                 {
49580                         switch(type)
49581                         {
49582                         case 1: var.destroy<CriticalityDiagnostics>(); break;
49583                         }
49584                         type = 0; ref_nested().clear();
49585                 }
49586                 template<typename V> static inline void enumerate(V& v)
49587                 {
49588                         v.template operator()<CriticalityDiagnostics>(1);
49589
49590                 }
49591                 protected:
49592                 template<typename V> bool decode(size_t index, V& v)
49593                 {
49594                         clear();
49595                         switch(index)
49596                         {
49597                         case 1: v(select_id_CriticalityDiagnostics()); return true;
49598                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
49599                         }
49600                         return false;
49601
49602                 }
49603                 template<typename V> bool encode(size_t index, V& v) const
49604                 {
49605                         if(index != type) return false;
49606                         switch(type)
49607                         {
49608                         case 1: v(var.as<CriticalityDiagnostics>()); return true;
49609                         }
49610                         return false;
49611
49612                 }
49613                 private:
49614                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49615                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49616                 union union_type
49617                 {
49618                         char dummy1[sizeof(CriticalityDiagnostics)];
49619
49620                 };
49621                 asn::variant<sizeof(union_type)> var;
49622                 size_t type {0};
49623
49624         };
49625         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49626         {
49627                 size_t get_index() const {return type;}
49628                 bool is_unknown() const { return type == 2; }
49629                 void clear() {type = 0;}
49630                 void select_id_CriticalityDiagnostics() { set(optional); type=1;}
49631                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49632                 template<typename V>  bool decode(V& v)
49633                 {
49634                         clear();
49635                         if(!v(ref_nested())) return false;
49636                         if(equal(optional)) { type = 1; return true; }
49637                         else { type = 2; return true;}
49638                         return false;
49639
49640                 }
49641                 template<typename V> bool encode(V& v) const
49642                 {
49643                         return v(ref_nested());
49644
49645                 }
49646                 protected:
49647                 template<typename V>  bool decode(size_t index, V& v)
49648                 {
49649                         clear();
49650                         switch(index)
49651                         {
49652                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
49653                         case 2: type = 2; return v(ref_nested());
49654                         ref_nested().clear();
49655                         }
49656                         return false;
49657
49658                 }
49659                 template<typename V> bool encode(size_t index, V& v) const
49660                 {
49661                         if(index != type) {return false;} return v(ref_nested());
49662
49663                 }
49664                 private:
49665                 size_t type {0};
49666
49667         };
49668
49669 };
49670 /*
49671 ResetResponse ::= SEQUENCE {
49672         protocolIEs             ProtocolIE-Container    {{ResetResponse-IEs}},
49673         ...
49674 }
49675 */
49676
49677 struct ResetResponse : asn::sequence<1, 0, true, 0>
49678 {
49679         static constexpr const char* name() {return "ResetResponse";}
49680         using parent_t = asn::sequence<1, 0, true, 0>;
49681         struct protocolIEs_t : ProtocolIE_Container<ResetResponse_IEs>
49682         {
49683                 static constexpr const char* name() {return "protocolIEs_t";}
49684                 using parent_t = ProtocolIE_Container<ResetResponse_IEs>;
49685
49686         };
49687         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49688         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49689         template<typename V> void decode(V& v)
49690         {
49691                 v(protocolIEs);
49692
49693         };
49694         template<typename V> void encode(V& v) const
49695         {
49696                 v(protocolIEs);
49697
49698         };
49699         void clear()
49700         {
49701                 protocolIEs.clear();
49702
49703         };
49704         private:
49705         protocolIEs_t   protocolIEs;
49706
49707 };
49708 /*
49709 ResourceStatusFailure-IEs X2AP-PROTOCOL-IES ::= {
49710         { ID id-ENB1-Measurement-ID                                             CRITICALITY reject      TYPE Measurement-ID                                                                     PRESENCE mandatory}|
49711         { ID id-ENB2-Measurement-ID                                             CRITICALITY reject      TYPE Measurement-ID                                                                     PRESENCE mandatory}|
49712         { ID id-Cause                                                                   CRITICALITY ignore      TYPE Cause                                                                                      PRESENCE mandatory}|
49713         { ID id-CriticalityDiagnostics                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional}|
49714         { ID id-CompleteFailureCauseInformation-List    CRITICALITY ignore      TYPE CompleteFailureCauseInformation-List       PRESENCE optional},
49715         ...
49716 }
49717 */
49718
49719 struct ResourceStatusFailure_IEs
49720 {
49721         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
49722         {
49723                 size_t get_index() const {return type;}
49724                 bool is_unknown() const { return type == 6; }
49725                 void clear() {type = 0;}
49726                 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
49727                 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
49728                 void select_id_Cause() { set(id_Cause); type=3;}
49729                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
49730                 void select_id_CompleteFailureCauseInformation_List() { set(id_CompleteFailureCauseInformation_List); type=5;}
49731                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
49732                 template<typename V>  bool decode(V& v)
49733                 {
49734                         clear();
49735                         if(!v(ref_nested())) return false;
49736                         if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
49737                         else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
49738                         else if(equal(id_Cause)) { type = 3; return true; }
49739                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
49740                         else if(equal(id_CompleteFailureCauseInformation_List)) { type = 5; return true; }
49741                         else { type = 6; return true;}
49742                         return false;
49743
49744                 }
49745                 template<typename V> bool encode(V& v) const
49746                 {
49747                         return v(ref_nested());
49748
49749                 }
49750                 protected:
49751                 template<typename V>  bool decode(size_t index, V& v)
49752                 {
49753                         clear();
49754                         switch(index)
49755                         {
49756                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
49757                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
49758                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
49759                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
49760                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CompleteFailureCauseInformation_List);} return false;
49761                         case 6: type = 6; return v(ref_nested());
49762                         ref_nested().clear();
49763                         }
49764                         return false;
49765
49766                 }
49767                 template<typename V> bool encode(size_t index, V& v) const
49768                 {
49769                         if(index != type) {return false;} return v(ref_nested());
49770
49771                 }
49772                 private:
49773                 size_t type {0};
49774
49775         };
49776         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
49777         {
49778                 size_t get_index() const {return type;}
49779                 bool is_unknown() const { return type == 6; }
49780                 void clear() {type = 0;}
49781                 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
49782                 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
49783                 void select_id_Cause() { set(ignore); type=3;}
49784                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
49785                 void select_id_CompleteFailureCauseInformation_List() { set(ignore); type=5;}
49786                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
49787                 template<typename V>  bool decode(V& v)
49788                 {
49789                         clear();
49790                         if(!v(ref_nested())) return false;
49791                         if(equal(reject)) { type = 1; return true; }
49792                         else if(equal(reject)) { type = 2; return true; }
49793                         else if(equal(ignore)) { type = 3; return true; }
49794                         else if(equal(ignore)) { type = 4; return true; }
49795                         else if(equal(ignore)) { type = 5; return true; }
49796                         else { type = 6; return true;}
49797                         return false;
49798
49799                 }
49800                 template<typename V> bool encode(V& v) const
49801                 {
49802                         return v(ref_nested());
49803
49804                 }
49805                 protected:
49806                 template<typename V>  bool decode(size_t index, V& v)
49807                 {
49808                         clear();
49809                         switch(index)
49810                         {
49811                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
49812                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
49813                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
49814                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
49815                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
49816                         case 6: type = 6; return v(ref_nested());
49817                         ref_nested().clear();
49818                         }
49819                         return false;
49820
49821                 }
49822                 template<typename V> bool encode(size_t index, V& v) const
49823                 {
49824                         if(index != type) {return false;} return v(ref_nested());
49825
49826                 }
49827                 private:
49828                 size_t type {0};
49829
49830         };
49831         struct Value_t : asn::typefield<true>
49832         {
49833                 ~Value_t()      {clear();}
49834                 size_t get_index() const {return type;}
49835                 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
49836                 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
49837                 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
49838                 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
49839                 Cause& select_id_Cause() { return set<Cause>(3); }
49840                 Cause const* get_id_Cause() const { return get<Cause>(3); }
49841                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
49842                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
49843                 CompleteFailureCauseInformation_List& select_id_CompleteFailureCauseInformation_List() { return set<CompleteFailureCauseInformation_List>(5); }
49844                 CompleteFailureCauseInformation_List const* get_id_CompleteFailureCauseInformation_List() const { return get<CompleteFailureCauseInformation_List>(5); }
49845                 bool is_unknown() const { return type == 6; }
49846                 void clear()
49847                 {
49848                         switch(type)
49849                         {
49850                         case 1: var.destroy<Measurement_ID>(); break;
49851                         case 2: var.destroy<Measurement_ID>(); break;
49852                         case 3: var.destroy<Cause>(); break;
49853                         case 4: var.destroy<CriticalityDiagnostics>(); break;
49854                         case 5: var.destroy<CompleteFailureCauseInformation_List>(); break;
49855                         }
49856                         type = 0; ref_nested().clear();
49857                 }
49858                 template<typename V> static inline void enumerate(V& v)
49859                 {
49860                         v.template operator()<Measurement_ID>(1);
49861                         v.template operator()<Measurement_ID>(2);
49862                         v.template operator()<Cause>(3);
49863                         v.template operator()<CriticalityDiagnostics>(4);
49864                         v.template operator()<CompleteFailureCauseInformation_List>(5);
49865
49866                 }
49867                 protected:
49868                 template<typename V> bool decode(size_t index, V& v)
49869                 {
49870                         clear();
49871                         switch(index)
49872                         {
49873                         case 1: v(select_id_ENB1_Measurement_ID()); return true;
49874                         case 2: v(select_id_ENB2_Measurement_ID()); return true;
49875                         case 3: v(select_id_Cause()); return true;
49876                         case 4: v(select_id_CriticalityDiagnostics()); return true;
49877                         case 5: v(select_id_CompleteFailureCauseInformation_List()); return true;
49878                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
49879                         }
49880                         return false;
49881
49882                 }
49883                 template<typename V> bool encode(size_t index, V& v) const
49884                 {
49885                         if(index != type) return false;
49886                         switch(type)
49887                         {
49888                         case 1: v(var.as<Measurement_ID>()); return true;
49889                         case 2: v(var.as<Measurement_ID>()); return true;
49890                         case 3: v(var.as<Cause>()); return true;
49891                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
49892                         case 5: v(var.as<CompleteFailureCauseInformation_List>()); return true;
49893                         }
49894                         return false;
49895
49896                 }
49897                 private:
49898                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
49899                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
49900                 union union_type
49901                 {
49902                         char dummy1[sizeof(Cause)];
49903                         char dummy2[sizeof(CompleteFailureCauseInformation_List)];
49904                         char dummy3[sizeof(CriticalityDiagnostics)];
49905                         char dummy4[sizeof(Measurement_ID)];
49906
49907                 };
49908                 asn::variant<sizeof(union_type)> var;
49909                 size_t type {0};
49910
49911         };
49912         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
49913         {
49914                 size_t get_index() const {return type;}
49915                 bool is_unknown() const { return type == 6; }
49916                 void clear() {type = 0;}
49917                 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
49918                 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
49919                 void select_id_Cause() { set(mandatory); type=3;}
49920                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
49921                 void select_id_CompleteFailureCauseInformation_List() { set(optional); type=5;}
49922                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
49923                 template<typename V>  bool decode(V& v)
49924                 {
49925                         clear();
49926                         if(!v(ref_nested())) return false;
49927                         if(equal(mandatory)) { type = 1; return true; }
49928                         else if(equal(mandatory)) { type = 2; return true; }
49929                         else if(equal(mandatory)) { type = 3; return true; }
49930                         else if(equal(optional)) { type = 4; return true; }
49931                         else if(equal(optional)) { type = 5; return true; }
49932                         else { type = 6; return true;}
49933                         return false;
49934
49935                 }
49936                 template<typename V> bool encode(V& v) const
49937                 {
49938                         return v(ref_nested());
49939
49940                 }
49941                 protected:
49942                 template<typename V>  bool decode(size_t index, V& v)
49943                 {
49944                         clear();
49945                         switch(index)
49946                         {
49947                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
49948                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
49949                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
49950                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
49951                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
49952                         case 6: type = 6; return v(ref_nested());
49953                         ref_nested().clear();
49954                         }
49955                         return false;
49956
49957                 }
49958                 template<typename V> bool encode(size_t index, V& v) const
49959                 {
49960                         if(index != type) {return false;} return v(ref_nested());
49961
49962                 }
49963                 private:
49964                 size_t type {0};
49965
49966         };
49967
49968 };
49969 /*
49970 ResourceStatusFailure ::= SEQUENCE {
49971         protocolIEs             ProtocolIE-Container    {{ResourceStatusFailure-IEs}},
49972         ...
49973 }
49974 */
49975
49976 struct ResourceStatusFailure : asn::sequence<1, 0, true, 0>
49977 {
49978         static constexpr const char* name() {return "ResourceStatusFailure";}
49979         using parent_t = asn::sequence<1, 0, true, 0>;
49980         struct protocolIEs_t : ProtocolIE_Container<ResourceStatusFailure_IEs>
49981         {
49982                 static constexpr const char* name() {return "protocolIEs_t";}
49983                 using parent_t = ProtocolIE_Container<ResourceStatusFailure_IEs>;
49984
49985         };
49986         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
49987         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
49988         template<typename V> void decode(V& v)
49989         {
49990                 v(protocolIEs);
49991
49992         };
49993         template<typename V> void encode(V& v) const
49994         {
49995                 v(protocolIEs);
49996
49997         };
49998         void clear()
49999         {
50000                 protocolIEs.clear();
50001
50002         };
50003         private:
50004         protocolIEs_t   protocolIEs;
50005
50006 };
50007 /*
50008 ResourceStatusRequest-IEs X2AP-PROTOCOL-IES ::= {
50009         { ID id-ENB1-Measurement-ID                     CRITICALITY reject      TYPE Measurement-ID                                     PRESENCE mandatory}|
50010         { ID id-ENB2-Measurement-ID                     CRITICALITY ignore      TYPE Measurement-ID                                     PRESENCE conditional}|-- The IE shall be present if the Registration Request IE is set to “Stop”, “Partial stop” or to “Add”--
50011         { ID id-Registration-Request            CRITICALITY reject      TYPE Registration-Request                       PRESENCE mandatory}|
50012         { ID id-ReportCharacteristics           CRITICALITY reject      TYPE ReportCharacteristics                      PRESENCE optional}|
50013         { ID id-CellToReport                            CRITICALITY ignore      TYPE CellToReport-List                          PRESENCE mandatory}|
50014         { ID id-ReportingPeriodicity            CRITICALITY ignore      TYPE ReportingPeriodicity                       PRESENCE optional}|
50015         { ID id-PartialSuccessIndicator         CRITICALITY ignore      TYPE PartialSuccessIndicator            PRESENCE optional}|
50016         { ID id-ReportingPeriodicityRSRPMR      CRITICALITY ignore      TYPE ReportingPeriodicityRSRPMR         PRESENCE optional}|
50017         { ID id-ReportingPeriodicityCSIR        CRITICALITY ignore      TYPE ReportingPeriodicityCSIR           PRESENCE optional},
50018         ...
50019 }
50020 */
50021
50022 struct ResourceStatusRequest_IEs
50023 {
50024         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50025         {
50026                 size_t get_index() const {return type;}
50027                 bool is_unknown() const { return type == 10; }
50028                 void clear() {type = 0;}
50029                 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50030                 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50031                 void select_id_Registration_Request() { set(id_Registration_Request); type=3;}
50032                 void select_id_ReportCharacteristics() { set(id_ReportCharacteristics); type=4;}
50033                 void select_id_CellToReport() { set(id_CellToReport); type=5;}
50034                 void select_id_ReportingPeriodicity() { set(id_ReportingPeriodicity); type=6;}
50035                 void select_id_PartialSuccessIndicator() { set(id_PartialSuccessIndicator); type=7;}
50036                 void select_id_ReportingPeriodicityRSRPMR() { set(id_ReportingPeriodicityRSRPMR); type=8;}
50037                 void select_id_ReportingPeriodicityCSIR() { set(id_ReportingPeriodicityCSIR); type=9;}
50038                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50039                 template<typename V>  bool decode(V& v)
50040                 {
50041                         clear();
50042                         if(!v(ref_nested())) return false;
50043                         if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50044                         else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50045                         else if(equal(id_Registration_Request)) { type = 3; return true; }
50046                         else if(equal(id_ReportCharacteristics)) { type = 4; return true; }
50047                         else if(equal(id_CellToReport)) { type = 5; return true; }
50048                         else if(equal(id_ReportingPeriodicity)) { type = 6; return true; }
50049                         else if(equal(id_PartialSuccessIndicator)) { type = 7; return true; }
50050                         else if(equal(id_ReportingPeriodicityRSRPMR)) { type = 8; return true; }
50051                         else if(equal(id_ReportingPeriodicityCSIR)) { type = 9; return true; }
50052                         else { type = 10; return true;}
50053                         return false;
50054
50055                 }
50056                 template<typename V> bool encode(V& v) const
50057                 {
50058                         return v(ref_nested());
50059
50060                 }
50061                 protected:
50062                 template<typename V>  bool decode(size_t index, V& v)
50063                 {
50064                         clear();
50065                         switch(index)
50066                         {
50067                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50068                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50069                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Registration_Request);} return false;
50070                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ReportCharacteristics);} return false;
50071                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CellToReport);} return false;
50072                         case 6: type = 6; if(v(ref_nested())) { return equal(id_ReportingPeriodicity);} return false;
50073                         case 7: type = 7; if(v(ref_nested())) { return equal(id_PartialSuccessIndicator);} return false;
50074                         case 8: type = 8; if(v(ref_nested())) { return equal(id_ReportingPeriodicityRSRPMR);} return false;
50075                         case 9: type = 9; if(v(ref_nested())) { return equal(id_ReportingPeriodicityCSIR);} return false;
50076                         case 10: type = 10; return v(ref_nested());
50077                         ref_nested().clear();
50078                         }
50079                         return false;
50080
50081                 }
50082                 template<typename V> bool encode(size_t index, V& v) const
50083                 {
50084                         if(index != type) {return false;} return v(ref_nested());
50085
50086                 }
50087                 private:
50088                 size_t type {0};
50089
50090         };
50091         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50092         {
50093                 size_t get_index() const {return type;}
50094                 bool is_unknown() const { return type == 10; }
50095                 void clear() {type = 0;}
50096                 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50097                 void select_id_ENB2_Measurement_ID() { set(ignore); type=2;}
50098                 void select_id_Registration_Request() { set(reject); type=3;}
50099                 void select_id_ReportCharacteristics() { set(reject); type=4;}
50100                 void select_id_CellToReport() { set(ignore); type=5;}
50101                 void select_id_ReportingPeriodicity() { set(ignore); type=6;}
50102                 void select_id_PartialSuccessIndicator() { set(ignore); type=7;}
50103                 void select_id_ReportingPeriodicityRSRPMR() { set(ignore); type=8;}
50104                 void select_id_ReportingPeriodicityCSIR() { set(ignore); type=9;}
50105                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50106                 template<typename V>  bool decode(V& v)
50107                 {
50108                         clear();
50109                         if(!v(ref_nested())) return false;
50110                         if(equal(reject)) { type = 1; return true; }
50111                         else if(equal(ignore)) { type = 2; return true; }
50112                         else if(equal(reject)) { type = 3; return true; }
50113                         else if(equal(reject)) { type = 4; return true; }
50114                         else if(equal(ignore)) { type = 5; return true; }
50115                         else if(equal(ignore)) { type = 6; return true; }
50116                         else if(equal(ignore)) { type = 7; return true; }
50117                         else if(equal(ignore)) { type = 8; return true; }
50118                         else if(equal(ignore)) { type = 9; return true; }
50119                         else { type = 10; return true;}
50120                         return false;
50121
50122                 }
50123                 template<typename V> bool encode(V& v) const
50124                 {
50125                         return v(ref_nested());
50126
50127                 }
50128                 protected:
50129                 template<typename V>  bool decode(size_t index, V& v)
50130                 {
50131                         clear();
50132                         switch(index)
50133                         {
50134                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50135                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
50136                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
50137                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
50138                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
50139                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
50140                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
50141                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
50142                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
50143                         case 10: type = 10; return v(ref_nested());
50144                         ref_nested().clear();
50145                         }
50146                         return false;
50147
50148                 }
50149                 template<typename V> bool encode(size_t index, V& v) const
50150                 {
50151                         if(index != type) {return false;} return v(ref_nested());
50152
50153                 }
50154                 private:
50155                 size_t type {0};
50156
50157         };
50158         struct Value_t : asn::typefield<true>
50159         {
50160                 ~Value_t()      {clear();}
50161                 size_t get_index() const {return type;}
50162                 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50163                 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50164                 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50165                 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50166                 Registration_Request& select_id_Registration_Request() { return set<Registration_Request>(3); }
50167                 Registration_Request const* get_id_Registration_Request() const { return get<Registration_Request>(3); }
50168                 ReportCharacteristics& select_id_ReportCharacteristics() { return set<ReportCharacteristics>(4); }
50169                 ReportCharacteristics const* get_id_ReportCharacteristics() const { return get<ReportCharacteristics>(4); }
50170                 CellToReport_List& select_id_CellToReport() { return set<CellToReport_List>(5); }
50171                 CellToReport_List const* get_id_CellToReport() const { return get<CellToReport_List>(5); }
50172                 ReportingPeriodicity& select_id_ReportingPeriodicity() { return set<ReportingPeriodicity>(6); }
50173                 ReportingPeriodicity const* get_id_ReportingPeriodicity() const { return get<ReportingPeriodicity>(6); }
50174                 PartialSuccessIndicator& select_id_PartialSuccessIndicator() { return set<PartialSuccessIndicator>(7); }
50175                 PartialSuccessIndicator const* get_id_PartialSuccessIndicator() const { return get<PartialSuccessIndicator>(7); }
50176                 ReportingPeriodicityRSRPMR& select_id_ReportingPeriodicityRSRPMR() { return set<ReportingPeriodicityRSRPMR>(8); }
50177                 ReportingPeriodicityRSRPMR const* get_id_ReportingPeriodicityRSRPMR() const { return get<ReportingPeriodicityRSRPMR>(8); }
50178                 ReportingPeriodicityCSIR& select_id_ReportingPeriodicityCSIR() { return set<ReportingPeriodicityCSIR>(9); }
50179                 ReportingPeriodicityCSIR const* get_id_ReportingPeriodicityCSIR() const { return get<ReportingPeriodicityCSIR>(9); }
50180                 bool is_unknown() const { return type == 10; }
50181                 void clear()
50182                 {
50183                         switch(type)
50184                         {
50185                         case 1: var.destroy<Measurement_ID>(); break;
50186                         case 2: var.destroy<Measurement_ID>(); break;
50187                         case 3: var.destroy<Registration_Request>(); break;
50188                         case 4: var.destroy<ReportCharacteristics>(); break;
50189                         case 5: var.destroy<CellToReport_List>(); break;
50190                         case 6: var.destroy<ReportingPeriodicity>(); break;
50191                         case 7: var.destroy<PartialSuccessIndicator>(); break;
50192                         case 8: var.destroy<ReportingPeriodicityRSRPMR>(); break;
50193                         case 9: var.destroy<ReportingPeriodicityCSIR>(); break;
50194                         }
50195                         type = 0; ref_nested().clear();
50196                 }
50197                 template<typename V> static inline void enumerate(V& v)
50198                 {
50199                         v.template operator()<Measurement_ID>(1);
50200                         v.template operator()<Measurement_ID>(2);
50201                         v.template operator()<Registration_Request>(3);
50202                         v.template operator()<ReportCharacteristics>(4);
50203                         v.template operator()<CellToReport_List>(5);
50204                         v.template operator()<ReportingPeriodicity>(6);
50205                         v.template operator()<PartialSuccessIndicator>(7);
50206                         v.template operator()<ReportingPeriodicityRSRPMR>(8);
50207                         v.template operator()<ReportingPeriodicityCSIR>(9);
50208
50209                 }
50210                 protected:
50211                 template<typename V> bool decode(size_t index, V& v)
50212                 {
50213                         clear();
50214                         switch(index)
50215                         {
50216                         case 1: v(select_id_ENB1_Measurement_ID()); return true;
50217                         case 2: v(select_id_ENB2_Measurement_ID()); return true;
50218                         case 3: v(select_id_Registration_Request()); return true;
50219                         case 4: v(select_id_ReportCharacteristics()); return true;
50220                         case 5: v(select_id_CellToReport()); return true;
50221                         case 6: v(select_id_ReportingPeriodicity()); return true;
50222                         case 7: v(select_id_PartialSuccessIndicator()); return true;
50223                         case 8: v(select_id_ReportingPeriodicityRSRPMR()); return true;
50224                         case 9: v(select_id_ReportingPeriodicityCSIR()); return true;
50225                         case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
50226                         }
50227                         return false;
50228
50229                 }
50230                 template<typename V> bool encode(size_t index, V& v) const
50231                 {
50232                         if(index != type) return false;
50233                         switch(type)
50234                         {
50235                         case 1: v(var.as<Measurement_ID>()); return true;
50236                         case 2: v(var.as<Measurement_ID>()); return true;
50237                         case 3: v(var.as<Registration_Request>()); return true;
50238                         case 4: v(var.as<ReportCharacteristics>()); return true;
50239                         case 5: v(var.as<CellToReport_List>()); return true;
50240                         case 6: v(var.as<ReportingPeriodicity>()); return true;
50241                         case 7: v(var.as<PartialSuccessIndicator>()); return true;
50242                         case 8: v(var.as<ReportingPeriodicityRSRPMR>()); return true;
50243                         case 9: v(var.as<ReportingPeriodicityCSIR>()); return true;
50244                         }
50245                         return false;
50246
50247                 }
50248                 private:
50249                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50250                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50251                 union union_type
50252                 {
50253                         char dummy1[sizeof(CellToReport_List)];
50254                         char dummy2[sizeof(Measurement_ID)];
50255                         char dummy3[sizeof(PartialSuccessIndicator)];
50256                         char dummy4[sizeof(Registration_Request)];
50257                         char dummy5[sizeof(ReportCharacteristics)];
50258                         char dummy6[sizeof(ReportingPeriodicity)];
50259                         char dummy7[sizeof(ReportingPeriodicityCSIR)];
50260                         char dummy8[sizeof(ReportingPeriodicityRSRPMR)];
50261
50262                 };
50263                 asn::variant<sizeof(union_type)> var;
50264                 size_t type {0};
50265
50266         };
50267         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50268         {
50269                 size_t get_index() const {return type;}
50270                 bool is_unknown() const { return type == 10; }
50271                 void clear() {type = 0;}
50272                 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50273                 void select_id_ENB2_Measurement_ID() { set(conditional); type=2;}
50274                 void select_id_Registration_Request() { set(mandatory); type=3;}
50275                 void select_id_ReportCharacteristics() { set(optional); type=4;}
50276                 void select_id_CellToReport() { set(mandatory); type=5;}
50277                 void select_id_ReportingPeriodicity() { set(optional); type=6;}
50278                 void select_id_PartialSuccessIndicator() { set(optional); type=7;}
50279                 void select_id_ReportingPeriodicityRSRPMR() { set(optional); type=8;}
50280                 void select_id_ReportingPeriodicityCSIR() { set(optional); type=9;}
50281                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50282                 template<typename V>  bool decode(V& v)
50283                 {
50284                         clear();
50285                         if(!v(ref_nested())) return false;
50286                         if(equal(mandatory)) { type = 1; return true; }
50287                         else if(equal(conditional)) { type = 2; return true; }
50288                         else if(equal(mandatory)) { type = 3; return true; }
50289                         else if(equal(optional)) { type = 4; return true; }
50290                         else if(equal(mandatory)) { type = 5; return true; }
50291                         else if(equal(optional)) { type = 6; return true; }
50292                         else if(equal(optional)) { type = 7; return true; }
50293                         else if(equal(optional)) { type = 8; return true; }
50294                         else if(equal(optional)) { type = 9; return true; }
50295                         else { type = 10; return true;}
50296                         return false;
50297
50298                 }
50299                 template<typename V> bool encode(V& v) const
50300                 {
50301                         return v(ref_nested());
50302
50303                 }
50304                 protected:
50305                 template<typename V>  bool decode(size_t index, V& v)
50306                 {
50307                         clear();
50308                         switch(index)
50309                         {
50310                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50311                         case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
50312                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
50313                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
50314                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
50315                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
50316                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
50317                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
50318                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
50319                         case 10: type = 10; return v(ref_nested());
50320                         ref_nested().clear();
50321                         }
50322                         return false;
50323
50324                 }
50325                 template<typename V> bool encode(size_t index, V& v) const
50326                 {
50327                         if(index != type) {return false;} return v(ref_nested());
50328
50329                 }
50330                 private:
50331                 size_t type {0};
50332
50333         };
50334
50335 };
50336 /*
50337 ResourceStatusRequest ::= SEQUENCE {
50338         protocolIEs             ProtocolIE-Container    {{ResourceStatusRequest-IEs}},
50339         ...
50340 }
50341 */
50342
50343 struct ResourceStatusRequest : asn::sequence<1, 0, true, 0>
50344 {
50345         static constexpr const char* name() {return "ResourceStatusRequest";}
50346         using parent_t = asn::sequence<1, 0, true, 0>;
50347         struct protocolIEs_t : ProtocolIE_Container<ResourceStatusRequest_IEs>
50348         {
50349                 static constexpr const char* name() {return "protocolIEs_t";}
50350                 using parent_t = ProtocolIE_Container<ResourceStatusRequest_IEs>;
50351
50352         };
50353         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50354         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50355         template<typename V> void decode(V& v)
50356         {
50357                 v(protocolIEs);
50358
50359         };
50360         template<typename V> void encode(V& v) const
50361         {
50362                 v(protocolIEs);
50363
50364         };
50365         void clear()
50366         {
50367                 protocolIEs.clear();
50368
50369         };
50370         private:
50371         protocolIEs_t   protocolIEs;
50372
50373 };
50374 /*
50375 ResourceStatusResponse-IEs X2AP-PROTOCOL-IES ::= {
50376         { ID id-ENB1-Measurement-ID                                     CRITICALITY reject      TYPE Measurement-ID                                                     PRESENCE mandatory}|
50377         { ID id-ENB2-Measurement-ID                                     CRITICALITY reject      TYPE Measurement-ID                                                     PRESENCE mandatory}|
50378         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics                                     PRESENCE optional}|
50379         { ID id-MeasurementInitiationResult-List        CRITICALITY ignore      TYPE MeasurementInitiationResult-List   PRESENCE optional},
50380         ...
50381 }
50382 */
50383
50384 struct ResourceStatusResponse_IEs
50385 {
50386         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50387         {
50388                 size_t get_index() const {return type;}
50389                 bool is_unknown() const { return type == 5; }
50390                 void clear() {type = 0;}
50391                 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50392                 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50393                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
50394                 void select_id_MeasurementInitiationResult_List() { set(id_MeasurementInitiationResult_List); type=4;}
50395                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50396                 template<typename V>  bool decode(V& v)
50397                 {
50398                         clear();
50399                         if(!v(ref_nested())) return false;
50400                         if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50401                         else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50402                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
50403                         else if(equal(id_MeasurementInitiationResult_List)) { type = 4; return true; }
50404                         else { type = 5; return true;}
50405                         return false;
50406
50407                 }
50408                 template<typename V> bool encode(V& v) const
50409                 {
50410                         return v(ref_nested());
50411
50412                 }
50413                 protected:
50414                 template<typename V>  bool decode(size_t index, V& v)
50415                 {
50416                         clear();
50417                         switch(index)
50418                         {
50419                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50420                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50421                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
50422                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeasurementInitiationResult_List);} return false;
50423                         case 5: type = 5; return v(ref_nested());
50424                         ref_nested().clear();
50425                         }
50426                         return false;
50427
50428                 }
50429                 template<typename V> bool encode(size_t index, V& v) const
50430                 {
50431                         if(index != type) {return false;} return v(ref_nested());
50432
50433                 }
50434                 private:
50435                 size_t type {0};
50436
50437         };
50438         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50439         {
50440                 size_t get_index() const {return type;}
50441                 bool is_unknown() const { return type == 5; }
50442                 void clear() {type = 0;}
50443                 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50444                 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
50445                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
50446                 void select_id_MeasurementInitiationResult_List() { set(ignore); type=4;}
50447                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50448                 template<typename V>  bool decode(V& v)
50449                 {
50450                         clear();
50451                         if(!v(ref_nested())) return false;
50452                         if(equal(reject)) { type = 1; return true; }
50453                         else if(equal(reject)) { type = 2; return true; }
50454                         else if(equal(ignore)) { type = 3; return true; }
50455                         else if(equal(ignore)) { type = 4; return true; }
50456                         else { type = 5; return true;}
50457                         return false;
50458
50459                 }
50460                 template<typename V> bool encode(V& v) const
50461                 {
50462                         return v(ref_nested());
50463
50464                 }
50465                 protected:
50466                 template<typename V>  bool decode(size_t index, V& v)
50467                 {
50468                         clear();
50469                         switch(index)
50470                         {
50471                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50472                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
50473                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
50474                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
50475                         case 5: type = 5; return v(ref_nested());
50476                         ref_nested().clear();
50477                         }
50478                         return false;
50479
50480                 }
50481                 template<typename V> bool encode(size_t index, V& v) const
50482                 {
50483                         if(index != type) {return false;} return v(ref_nested());
50484
50485                 }
50486                 private:
50487                 size_t type {0};
50488
50489         };
50490         struct Value_t : asn::typefield<true>
50491         {
50492                 ~Value_t()      {clear();}
50493                 size_t get_index() const {return type;}
50494                 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50495                 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50496                 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50497                 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50498                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
50499                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
50500                 MeasurementInitiationResult_List& select_id_MeasurementInitiationResult_List() { return set<MeasurementInitiationResult_List>(4); }
50501                 MeasurementInitiationResult_List const* get_id_MeasurementInitiationResult_List() const { return get<MeasurementInitiationResult_List>(4); }
50502                 bool is_unknown() const { return type == 5; }
50503                 void clear()
50504                 {
50505                         switch(type)
50506                         {
50507                         case 1: var.destroy<Measurement_ID>(); break;
50508                         case 2: var.destroy<Measurement_ID>(); break;
50509                         case 3: var.destroy<CriticalityDiagnostics>(); break;
50510                         case 4: var.destroy<MeasurementInitiationResult_List>(); break;
50511                         }
50512                         type = 0; ref_nested().clear();
50513                 }
50514                 template<typename V> static inline void enumerate(V& v)
50515                 {
50516                         v.template operator()<Measurement_ID>(1);
50517                         v.template operator()<Measurement_ID>(2);
50518                         v.template operator()<CriticalityDiagnostics>(3);
50519                         v.template operator()<MeasurementInitiationResult_List>(4);
50520
50521                 }
50522                 protected:
50523                 template<typename V> bool decode(size_t index, V& v)
50524                 {
50525                         clear();
50526                         switch(index)
50527                         {
50528                         case 1: v(select_id_ENB1_Measurement_ID()); return true;
50529                         case 2: v(select_id_ENB2_Measurement_ID()); return true;
50530                         case 3: v(select_id_CriticalityDiagnostics()); return true;
50531                         case 4: v(select_id_MeasurementInitiationResult_List()); return true;
50532                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
50533                         }
50534                         return false;
50535
50536                 }
50537                 template<typename V> bool encode(size_t index, V& v) const
50538                 {
50539                         if(index != type) return false;
50540                         switch(type)
50541                         {
50542                         case 1: v(var.as<Measurement_ID>()); return true;
50543                         case 2: v(var.as<Measurement_ID>()); return true;
50544                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
50545                         case 4: v(var.as<MeasurementInitiationResult_List>()); return true;
50546                         }
50547                         return false;
50548
50549                 }
50550                 private:
50551                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50552                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50553                 union union_type
50554                 {
50555                         char dummy1[sizeof(CriticalityDiagnostics)];
50556                         char dummy2[sizeof(MeasurementInitiationResult_List)];
50557                         char dummy3[sizeof(Measurement_ID)];
50558
50559                 };
50560                 asn::variant<sizeof(union_type)> var;
50561                 size_t type {0};
50562
50563         };
50564         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50565         {
50566                 size_t get_index() const {return type;}
50567                 bool is_unknown() const { return type == 5; }
50568                 void clear() {type = 0;}
50569                 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50570                 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
50571                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
50572                 void select_id_MeasurementInitiationResult_List() { set(optional); type=4;}
50573                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50574                 template<typename V>  bool decode(V& v)
50575                 {
50576                         clear();
50577                         if(!v(ref_nested())) return false;
50578                         if(equal(mandatory)) { type = 1; return true; }
50579                         else if(equal(mandatory)) { type = 2; return true; }
50580                         else if(equal(optional)) { type = 3; return true; }
50581                         else if(equal(optional)) { type = 4; return true; }
50582                         else { type = 5; return true;}
50583                         return false;
50584
50585                 }
50586                 template<typename V> bool encode(V& v) const
50587                 {
50588                         return v(ref_nested());
50589
50590                 }
50591                 protected:
50592                 template<typename V>  bool decode(size_t index, V& v)
50593                 {
50594                         clear();
50595                         switch(index)
50596                         {
50597                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50598                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
50599                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
50600                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
50601                         case 5: type = 5; return v(ref_nested());
50602                         ref_nested().clear();
50603                         }
50604                         return false;
50605
50606                 }
50607                 template<typename V> bool encode(size_t index, V& v) const
50608                 {
50609                         if(index != type) {return false;} return v(ref_nested());
50610
50611                 }
50612                 private:
50613                 size_t type {0};
50614
50615         };
50616
50617 };
50618 /*
50619 ResourceStatusResponse ::= SEQUENCE {
50620         protocolIEs             ProtocolIE-Container    {{ResourceStatusResponse-IEs}},
50621         ...
50622 }
50623 */
50624
50625 struct ResourceStatusResponse : asn::sequence<1, 0, true, 0>
50626 {
50627         static constexpr const char* name() {return "ResourceStatusResponse";}
50628         using parent_t = asn::sequence<1, 0, true, 0>;
50629         struct protocolIEs_t : ProtocolIE_Container<ResourceStatusResponse_IEs>
50630         {
50631                 static constexpr const char* name() {return "protocolIEs_t";}
50632                 using parent_t = ProtocolIE_Container<ResourceStatusResponse_IEs>;
50633
50634         };
50635         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50636         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50637         template<typename V> void decode(V& v)
50638         {
50639                 v(protocolIEs);
50640
50641         };
50642         template<typename V> void encode(V& v) const
50643         {
50644                 v(protocolIEs);
50645
50646         };
50647         void clear()
50648         {
50649                 protocolIEs.clear();
50650
50651         };
50652         private:
50653         protocolIEs_t   protocolIEs;
50654
50655 };
50656 /*
50657 ResourceStatusUpdate-IEs X2AP-PROTOCOL-IES ::= {
50658         { ID id-ENB1-Measurement-ID             CRITICALITY reject      TYPE Measurement-ID                                     PRESENCE mandatory}|
50659         { ID id-ENB2-Measurement-ID             CRITICALITY reject      TYPE Measurement-ID                                     PRESENCE mandatory}|
50660         { ID id-CellMeasurementResult   CRITICALITY ignore      TYPE CellMeasurementResult-List         PRESENCE mandatory},
50661         ...
50662 }
50663 */
50664
50665 struct ResourceStatusUpdate_IEs
50666 {
50667         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
50668         {
50669                 size_t get_index() const {return type;}
50670                 bool is_unknown() const { return type == 4; }
50671                 void clear() {type = 0;}
50672                 void select_id_ENB1_Measurement_ID() { set(id_ENB1_Measurement_ID); type=1;}
50673                 void select_id_ENB2_Measurement_ID() { set(id_ENB2_Measurement_ID); type=2;}
50674                 void select_id_CellMeasurementResult() { set(id_CellMeasurementResult); type=3;}
50675                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
50676                 template<typename V>  bool decode(V& v)
50677                 {
50678                         clear();
50679                         if(!v(ref_nested())) return false;
50680                         if(equal(id_ENB1_Measurement_ID)) { type = 1; return true; }
50681                         else if(equal(id_ENB2_Measurement_ID)) { type = 2; return true; }
50682                         else if(equal(id_CellMeasurementResult)) { type = 3; return true; }
50683                         else { type = 4; return true;}
50684                         return false;
50685
50686                 }
50687                 template<typename V> bool encode(V& v) const
50688                 {
50689                         return v(ref_nested());
50690
50691                 }
50692                 protected:
50693                 template<typename V>  bool decode(size_t index, V& v)
50694                 {
50695                         clear();
50696                         switch(index)
50697                         {
50698                         case 1: type = 1; if(v(ref_nested())) { return equal(id_ENB1_Measurement_ID);} return false;
50699                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ENB2_Measurement_ID);} return false;
50700                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CellMeasurementResult);} return false;
50701                         case 4: type = 4; return v(ref_nested());
50702                         ref_nested().clear();
50703                         }
50704                         return false;
50705
50706                 }
50707                 template<typename V> bool encode(size_t index, V& v) const
50708                 {
50709                         if(index != type) {return false;} return v(ref_nested());
50710
50711                 }
50712                 private:
50713                 size_t type {0};
50714
50715         };
50716         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
50717         {
50718                 size_t get_index() const {return type;}
50719                 bool is_unknown() const { return type == 4; }
50720                 void clear() {type = 0;}
50721                 void select_id_ENB1_Measurement_ID() { set(reject); type=1;}
50722                 void select_id_ENB2_Measurement_ID() { set(reject); type=2;}
50723                 void select_id_CellMeasurementResult() { set(ignore); type=3;}
50724                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
50725                 template<typename V>  bool decode(V& v)
50726                 {
50727                         clear();
50728                         if(!v(ref_nested())) return false;
50729                         if(equal(reject)) { type = 1; return true; }
50730                         else if(equal(reject)) { type = 2; return true; }
50731                         else if(equal(ignore)) { type = 3; return true; }
50732                         else { type = 4; return true;}
50733                         return false;
50734
50735                 }
50736                 template<typename V> bool encode(V& v) const
50737                 {
50738                         return v(ref_nested());
50739
50740                 }
50741                 protected:
50742                 template<typename V>  bool decode(size_t index, V& v)
50743                 {
50744                         clear();
50745                         switch(index)
50746                         {
50747                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
50748                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
50749                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
50750                         case 4: type = 4; return v(ref_nested());
50751                         ref_nested().clear();
50752                         }
50753                         return false;
50754
50755                 }
50756                 template<typename V> bool encode(size_t index, V& v) const
50757                 {
50758                         if(index != type) {return false;} return v(ref_nested());
50759
50760                 }
50761                 private:
50762                 size_t type {0};
50763
50764         };
50765         struct Value_t : asn::typefield<true>
50766         {
50767                 ~Value_t()      {clear();}
50768                 size_t get_index() const {return type;}
50769                 Measurement_ID& select_id_ENB1_Measurement_ID() { return set<Measurement_ID>(1); }
50770                 Measurement_ID const* get_id_ENB1_Measurement_ID() const { return get<Measurement_ID>(1); }
50771                 Measurement_ID& select_id_ENB2_Measurement_ID() { return set<Measurement_ID>(2); }
50772                 Measurement_ID const* get_id_ENB2_Measurement_ID() const { return get<Measurement_ID>(2); }
50773                 CellMeasurementResult_List& select_id_CellMeasurementResult() { return set<CellMeasurementResult_List>(3); }
50774                 CellMeasurementResult_List const* get_id_CellMeasurementResult() const { return get<CellMeasurementResult_List>(3); }
50775                 bool is_unknown() const { return type == 4; }
50776                 void clear()
50777                 {
50778                         switch(type)
50779                         {
50780                         case 1: var.destroy<Measurement_ID>(); break;
50781                         case 2: var.destroy<Measurement_ID>(); break;
50782                         case 3: var.destroy<CellMeasurementResult_List>(); break;
50783                         }
50784                         type = 0; ref_nested().clear();
50785                 }
50786                 template<typename V> static inline void enumerate(V& v)
50787                 {
50788                         v.template operator()<Measurement_ID>(1);
50789                         v.template operator()<Measurement_ID>(2);
50790                         v.template operator()<CellMeasurementResult_List>(3);
50791
50792                 }
50793                 protected:
50794                 template<typename V> bool decode(size_t index, V& v)
50795                 {
50796                         clear();
50797                         switch(index)
50798                         {
50799                         case 1: v(select_id_ENB1_Measurement_ID()); return true;
50800                         case 2: v(select_id_ENB2_Measurement_ID()); return true;
50801                         case 3: v(select_id_CellMeasurementResult()); return true;
50802                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
50803                         }
50804                         return false;
50805
50806                 }
50807                 template<typename V> bool encode(size_t index, V& v) const
50808                 {
50809                         if(index != type) return false;
50810                         switch(type)
50811                         {
50812                         case 1: v(var.as<Measurement_ID>()); return true;
50813                         case 2: v(var.as<Measurement_ID>()); return true;
50814                         case 3: v(var.as<CellMeasurementResult_List>()); return true;
50815                         }
50816                         return false;
50817
50818                 }
50819                 private:
50820                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
50821                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
50822                 union union_type
50823                 {
50824                         char dummy1[sizeof(CellMeasurementResult_List)];
50825                         char dummy2[sizeof(Measurement_ID)];
50826
50827                 };
50828                 asn::variant<sizeof(union_type)> var;
50829                 size_t type {0};
50830
50831         };
50832         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
50833         {
50834                 size_t get_index() const {return type;}
50835                 bool is_unknown() const { return type == 4; }
50836                 void clear() {type = 0;}
50837                 void select_id_ENB1_Measurement_ID() { set(mandatory); type=1;}
50838                 void select_id_ENB2_Measurement_ID() { set(mandatory); type=2;}
50839                 void select_id_CellMeasurementResult() { set(mandatory); type=3;}
50840                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
50841                 template<typename V>  bool decode(V& v)
50842                 {
50843                         clear();
50844                         if(!v(ref_nested())) return false;
50845                         if(equal(mandatory)) { type = 1; return true; }
50846                         else if(equal(mandatory)) { type = 2; return true; }
50847                         else if(equal(mandatory)) { type = 3; return true; }
50848                         else { type = 4; return true;}
50849                         return false;
50850
50851                 }
50852                 template<typename V> bool encode(V& v) const
50853                 {
50854                         return v(ref_nested());
50855
50856                 }
50857                 protected:
50858                 template<typename V>  bool decode(size_t index, V& v)
50859                 {
50860                         clear();
50861                         switch(index)
50862                         {
50863                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
50864                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
50865                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
50866                         case 4: type = 4; return v(ref_nested());
50867                         ref_nested().clear();
50868                         }
50869                         return false;
50870
50871                 }
50872                 template<typename V> bool encode(size_t index, V& v) const
50873                 {
50874                         if(index != type) {return false;} return v(ref_nested());
50875
50876                 }
50877                 private:
50878                 size_t type {0};
50879
50880         };
50881
50882 };
50883 /*
50884 ResourceStatusUpdate ::= SEQUENCE {
50885         protocolIEs             ProtocolIE-Container    {{ResourceStatusUpdate-IEs}},
50886         ...
50887 }
50888 */
50889
50890 struct ResourceStatusUpdate : asn::sequence<1, 0, true, 0>
50891 {
50892         static constexpr const char* name() {return "ResourceStatusUpdate";}
50893         using parent_t = asn::sequence<1, 0, true, 0>;
50894         struct protocolIEs_t : ProtocolIE_Container<ResourceStatusUpdate_IEs>
50895         {
50896                 static constexpr const char* name() {return "protocolIEs_t";}
50897                 using parent_t = ProtocolIE_Container<ResourceStatusUpdate_IEs>;
50898
50899         };
50900         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
50901         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
50902         template<typename V> void decode(V& v)
50903         {
50904                 v(protocolIEs);
50905
50906         };
50907         template<typename V> void encode(V& v) const
50908         {
50909                 v(protocolIEs);
50910
50911         };
50912         void clear()
50913         {
50914                 protocolIEs.clear();
50915
50916         };
50917         private:
50918         protocolIEs_t   protocolIEs;
50919
50920 };
50921 /*
50922 ResponseInformationSeNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
50923         ...
50924 }
50925 */
50926
50927 struct ResponseInformationSeNBReconfComp_SuccessItemExtIEs
50928 {
50929         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
50930         {
50931                 size_t get_index() const {return type;}
50932                 bool is_unknown() const { return type == 1; }
50933                 void clear() {type = 0;}
50934                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
50935                 template<typename V>  bool decode(V& v)
50936                 {
50937                         clear();
50938                         if(!v(ref_nested())) return false;
50939                         { type = 1; return true;}
50940                         return false;
50941
50942                 }
50943                 template<typename V> bool encode(V& v) const
50944                 {
50945                         return v(ref_nested());
50946
50947                 }
50948                 protected:
50949                 template<typename V>  bool decode(size_t index, V& v)
50950                 {
50951                         clear();
50952                         switch(index)
50953                         {
50954                         case 1: type = 1; return v(ref_nested());
50955                         ref_nested().clear();
50956                         }
50957                         return false;
50958
50959                 }
50960                 template<typename V> bool encode(size_t index, V& v) const
50961                 {
50962                         if(index != type) {return false;} return v(ref_nested());
50963
50964                 }
50965                 private:
50966                 size_t type {0};
50967
50968         };
50969         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
50970         {
50971                 size_t get_index() const {return type;}
50972                 bool is_unknown() const { return type == 1; }
50973                 void clear() {type = 0;}
50974                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
50975                 template<typename V>  bool decode(V& v)
50976                 {
50977                         clear();
50978                         if(!v(ref_nested())) return false;
50979                         { type = 1; return true;}
50980                         return false;
50981
50982                 }
50983                 template<typename V> bool encode(V& v) const
50984                 {
50985                         return v(ref_nested());
50986
50987                 }
50988                 protected:
50989                 template<typename V>  bool decode(size_t index, V& v)
50990                 {
50991                         clear();
50992                         switch(index)
50993                         {
50994                         case 1: type = 1; return v(ref_nested());
50995                         ref_nested().clear();
50996                         }
50997                         return false;
50998
50999                 }
51000                 template<typename V> bool encode(size_t index, V& v) const
51001                 {
51002                         if(index != type) {return false;} return v(ref_nested());
51003
51004                 }
51005                 private:
51006                 size_t type {0};
51007
51008         };
51009         struct Extension_t : asn::typefield<true>
51010         {
51011                 ~Extension_t()  {clear();}
51012                 size_t get_index() const {return type;}
51013                 bool is_unknown() const { return type == 1; }
51014                 void clear()
51015                 {
51016                         type = 0; ref_nested().clear();
51017                 }
51018                 template<typename V> static inline void enumerate(V& v)
51019                 {
51020
51021                 }
51022                 protected:
51023                 template<typename V> bool decode(size_t index, V& v)
51024                 {
51025                         clear();
51026                         switch(index)
51027                         {
51028                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51029                         }
51030                         return false;
51031
51032                 }
51033                 template<typename V> bool encode(size_t index, V& v) const
51034                 {
51035                         if(index != type) return false;
51036                         return false;
51037
51038                 }
51039                 private:
51040                 size_t type {0};
51041
51042         };
51043         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51044         {
51045                 size_t get_index() const {return type;}
51046                 bool is_unknown() const { return type == 1; }
51047                 void clear() {type = 0;}
51048                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51049                 template<typename V>  bool decode(V& v)
51050                 {
51051                         clear();
51052                         if(!v(ref_nested())) return false;
51053                         { type = 1; return true;}
51054                         return false;
51055
51056                 }
51057                 template<typename V> bool encode(V& v) const
51058                 {
51059                         return v(ref_nested());
51060
51061                 }
51062                 protected:
51063                 template<typename V>  bool decode(size_t index, V& v)
51064                 {
51065                         clear();
51066                         switch(index)
51067                         {
51068                         case 1: type = 1; return v(ref_nested());
51069                         ref_nested().clear();
51070                         }
51071                         return false;
51072
51073                 }
51074                 template<typename V> bool encode(size_t index, V& v) const
51075                 {
51076                         if(index != type) {return false;} return v(ref_nested());
51077
51078                 }
51079                 private:
51080                 size_t type {0};
51081
51082         };
51083
51084 };
51085 /*
51086 ResponseInformationSeNBReconfComp-SuccessItem ::= SEQUENCE {
51087         meNBtoSeNBContainer                             MeNBtoSeNBContainer OPTIONAL,
51088         iE-Extensions                                   ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-SuccessItemExtIEs} }    OPTIONAL,
51089         ...
51090 }
51091 */
51092
51093 struct ResponseInformationSeNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
51094 {
51095         static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-SuccessItem";}
51096         using parent_t = asn::sequence<2, 0, true, 2>;
51097         struct meNBtoSeNBContainer_t : MeNBtoSeNBContainer
51098         {
51099                 static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
51100                 using parent_t = MeNBtoSeNBContainer;
51101                 static constexpr bool optional = true;
51102
51103         };
51104         meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
51105         meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
51106         struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>
51107         {
51108                 static constexpr const char* name() {return "iE_Extensions_t";}
51109                 using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_SuccessItemExtIEs>;
51110                 static constexpr bool optional = true;
51111
51112         };
51113         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51114         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51115         template<typename V> void decode(V& v)
51116         {
51117                 v(meNBtoSeNBContainer);
51118                 v(iE_Extensions);
51119
51120         };
51121         template<typename V> void encode(V& v) const
51122         {
51123                 v(meNBtoSeNBContainer);
51124                 v(iE_Extensions);
51125
51126         };
51127         void clear()
51128         {
51129                 meNBtoSeNBContainer.clear();
51130                 iE_Extensions.clear();
51131
51132         };
51133         private:
51134         meNBtoSeNBContainer_t   meNBtoSeNBContainer;
51135         iE_Extensions_t iE_Extensions;
51136
51137 };
51138 /*
51139 ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51140         ...
51141 }
51142 */
51143
51144 struct ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs
51145 {
51146         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51147         {
51148                 size_t get_index() const {return type;}
51149                 bool is_unknown() const { return type == 1; }
51150                 void clear() {type = 0;}
51151                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51152                 template<typename V>  bool decode(V& v)
51153                 {
51154                         clear();
51155                         if(!v(ref_nested())) return false;
51156                         { type = 1; return true;}
51157                         return false;
51158
51159                 }
51160                 template<typename V> bool encode(V& v) const
51161                 {
51162                         return v(ref_nested());
51163
51164                 }
51165                 protected:
51166                 template<typename V>  bool decode(size_t index, V& v)
51167                 {
51168                         clear();
51169                         switch(index)
51170                         {
51171                         case 1: type = 1; return v(ref_nested());
51172                         ref_nested().clear();
51173                         }
51174                         return false;
51175
51176                 }
51177                 template<typename V> bool encode(size_t index, V& v) const
51178                 {
51179                         if(index != type) {return false;} return v(ref_nested());
51180
51181                 }
51182                 private:
51183                 size_t type {0};
51184
51185         };
51186         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51187         {
51188                 size_t get_index() const {return type;}
51189                 bool is_unknown() const { return type == 1; }
51190                 void clear() {type = 0;}
51191                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51192                 template<typename V>  bool decode(V& v)
51193                 {
51194                         clear();
51195                         if(!v(ref_nested())) return false;
51196                         { type = 1; return true;}
51197                         return false;
51198
51199                 }
51200                 template<typename V> bool encode(V& v) const
51201                 {
51202                         return v(ref_nested());
51203
51204                 }
51205                 protected:
51206                 template<typename V>  bool decode(size_t index, V& v)
51207                 {
51208                         clear();
51209                         switch(index)
51210                         {
51211                         case 1: type = 1; return v(ref_nested());
51212                         ref_nested().clear();
51213                         }
51214                         return false;
51215
51216                 }
51217                 template<typename V> bool encode(size_t index, V& v) const
51218                 {
51219                         if(index != type) {return false;} return v(ref_nested());
51220
51221                 }
51222                 private:
51223                 size_t type {0};
51224
51225         };
51226         struct Extension_t : asn::typefield<true>
51227         {
51228                 ~Extension_t()  {clear();}
51229                 size_t get_index() const {return type;}
51230                 bool is_unknown() const { return type == 1; }
51231                 void clear()
51232                 {
51233                         type = 0; ref_nested().clear();
51234                 }
51235                 template<typename V> static inline void enumerate(V& v)
51236                 {
51237
51238                 }
51239                 protected:
51240                 template<typename V> bool decode(size_t index, V& v)
51241                 {
51242                         clear();
51243                         switch(index)
51244                         {
51245                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51246                         }
51247                         return false;
51248
51249                 }
51250                 template<typename V> bool encode(size_t index, V& v) const
51251                 {
51252                         if(index != type) return false;
51253                         return false;
51254
51255                 }
51256                 private:
51257                 size_t type {0};
51258
51259         };
51260         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51261         {
51262                 size_t get_index() const {return type;}
51263                 bool is_unknown() const { return type == 1; }
51264                 void clear() {type = 0;}
51265                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51266                 template<typename V>  bool decode(V& v)
51267                 {
51268                         clear();
51269                         if(!v(ref_nested())) return false;
51270                         { type = 1; return true;}
51271                         return false;
51272
51273                 }
51274                 template<typename V> bool encode(V& v) const
51275                 {
51276                         return v(ref_nested());
51277
51278                 }
51279                 protected:
51280                 template<typename V>  bool decode(size_t index, V& v)
51281                 {
51282                         clear();
51283                         switch(index)
51284                         {
51285                         case 1: type = 1; return v(ref_nested());
51286                         ref_nested().clear();
51287                         }
51288                         return false;
51289
51290                 }
51291                 template<typename V> bool encode(size_t index, V& v) const
51292                 {
51293                         if(index != type) {return false;} return v(ref_nested());
51294
51295                 }
51296                 private:
51297                 size_t type {0};
51298
51299         };
51300
51301 };
51302 /*
51303 ResponseInformationSeNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
51304         cause                                                   Cause,
51305         meNBtoSeNBContainer                             MeNBtoSeNBContainer                                                                                                                                                                             OPTIONAL,
51306         iE-Extensions                                   ProtocolExtensionContainer { {ResponseInformationSeNBReconfComp-RejectByMeNBItemExtIEs} }       OPTIONAL,
51307         ...
51308 }
51309 */
51310
51311 struct ResponseInformationSeNBReconfComp_RejectByMeNBItem : asn::sequence<3, 0, true, 2>
51312 {
51313         static constexpr const char* name() {return "ResponseInformationSeNBReconfComp-RejectByMeNBItem";}
51314         using parent_t = asn::sequence<3, 0, true, 2>;
51315         struct cause_t : Cause
51316         {
51317                 static constexpr const char* name() {return "cause_t";}
51318                 using parent_t = Cause;
51319
51320         };
51321         cause_t& ref_cause() {return cause;}
51322         cause_t const& ref_cause() const {return cause;}
51323         struct meNBtoSeNBContainer_t : MeNBtoSeNBContainer
51324         {
51325                 static constexpr const char* name() {return "meNBtoSeNBContainer_t";}
51326                 using parent_t = MeNBtoSeNBContainer;
51327                 static constexpr bool optional = true;
51328
51329         };
51330         meNBtoSeNBContainer_t& set_meNBtoSeNBContainer() { meNBtoSeNBContainer.setpresent(true); return meNBtoSeNBContainer;}
51331         meNBtoSeNBContainer_t const* get_meNBtoSeNBContainer() const {return meNBtoSeNBContainer.is_valid() ? &meNBtoSeNBContainer : nullptr;}
51332         struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>
51333         {
51334                 static constexpr const char* name() {return "iE_Extensions_t";}
51335                 using parent_t = ProtocolExtensionContainer<ResponseInformationSeNBReconfComp_RejectByMeNBItemExtIEs>;
51336                 static constexpr bool optional = true;
51337
51338         };
51339         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51340         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51341         template<typename V> void decode(V& v)
51342         {
51343                 v(cause);
51344                 v(meNBtoSeNBContainer);
51345                 v(iE_Extensions);
51346
51347         };
51348         template<typename V> void encode(V& v) const
51349         {
51350                 v(cause);
51351                 v(meNBtoSeNBContainer);
51352                 v(iE_Extensions);
51353
51354         };
51355         void clear()
51356         {
51357                 cause.clear();
51358                 meNBtoSeNBContainer.clear();
51359                 iE_Extensions.clear();
51360
51361         };
51362         private:
51363         cause_t cause;
51364         meNBtoSeNBContainer_t   meNBtoSeNBContainer;
51365         iE_Extensions_t iE_Extensions;
51366
51367 };
51368 /*
51369 ResponseInformationSeNBReconfComp ::= CHOICE {
51370         success                         ResponseInformationSeNBReconfComp-SuccessItem,
51371         reject-by-MeNB          ResponseInformationSeNBReconfComp-RejectByMeNBItem,
51372         ...
51373 }
51374 */
51375
51376 struct ResponseInformationSeNBReconfComp : asn::choice<2, 0, true>
51377 {
51378         static constexpr const char* name() {return "ResponseInformationSeNBReconfComp";}
51379         using parent_t = asn::choice<2, 0, true>;
51380         index_type get_index() const {return index;}
51381         bool is_unknown() const {return index == 3;}
51382         void set_unknown() { set_index(3);  }
51383         ~ResponseInformationSeNBReconfComp() {clear();}
51384         struct success_t : ResponseInformationSeNBReconfComp_SuccessItem
51385         {
51386                 static constexpr const char* name() {return "success_t";}
51387                 using parent_t = ResponseInformationSeNBReconfComp_SuccessItem;
51388
51389         };
51390         struct reject_by_MeNB_t : ResponseInformationSeNBReconfComp_RejectByMeNBItem
51391         {
51392                 static constexpr const char* name() {return "reject_by_MeNB_t";}
51393                 using parent_t = ResponseInformationSeNBReconfComp_RejectByMeNBItem;
51394
51395         };
51396         void clear()
51397         {
51398                 switch(get_index())
51399                 {
51400                 case 1: var.destroy<success_t>(); break;
51401                 case 2: var.destroy<reject_by_MeNB_t>(); break;
51402                 }
51403                 index = 0;
51404                 base::clear();
51405         }
51406         template<typename V> bool decode(size_t idx, V& v)
51407         {
51408                 clear();
51409                 switch(idx)
51410                 {
51411                 case 1: set_index(1); return v(var.build<success_t>());
51412                 case 2: set_index(2); return v(var.build<reject_by_MeNB_t>());
51413                 }
51414                 return false;
51415
51416         }
51417         template<typename V> bool encode(V& v) const
51418         {
51419                 switch(get_index())
51420                 {
51421                 case 1: return v(var.as<success_t>());
51422                 case 2: return v(var.as<reject_by_MeNB_t>());
51423                 }
51424                 return false;
51425         }
51426         template<typename V> static inline void enumerate(V& v)
51427         {
51428                 v.template operator()<success_t>(1);
51429                 v.template operator()<reject_by_MeNB_t>(2);
51430
51431         }
51432         success_t& select_success() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_t>();} return var.as<success_t>();}
51433         success_t const* get_success() const { if(get_index() == 1) { return &var.as<success_t>();} return nullptr; }
51434         reject_by_MeNB_t& select_reject_by_MeNB() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_t>();} return var.as<reject_by_MeNB_t>();}
51435         reject_by_MeNB_t const* get_reject_by_MeNB() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_t>();} return nullptr; }
51436         private:
51437         void set_index(index_type i) {index = i; base::set();}
51438         union union_type
51439         {
51440                 char dummy1[sizeof(success_t)];
51441                 char dummy2[sizeof(reject_by_MeNB_t)];
51442
51443         };
51444         asn::variant<sizeof(union_type)>        var;
51445         index_type      index {0};
51446 };
51447 /*
51448 ResponseInformationSgNBReconfComp-SuccessItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51449         ...
51450 }
51451 */
51452
51453 struct ResponseInformationSgNBReconfComp_SuccessItemExtIEs
51454 {
51455         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51456         {
51457                 size_t get_index() const {return type;}
51458                 bool is_unknown() const { return type == 1; }
51459                 void clear() {type = 0;}
51460                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51461                 template<typename V>  bool decode(V& v)
51462                 {
51463                         clear();
51464                         if(!v(ref_nested())) return false;
51465                         { type = 1; return true;}
51466                         return false;
51467
51468                 }
51469                 template<typename V> bool encode(V& v) const
51470                 {
51471                         return v(ref_nested());
51472
51473                 }
51474                 protected:
51475                 template<typename V>  bool decode(size_t index, V& v)
51476                 {
51477                         clear();
51478                         switch(index)
51479                         {
51480                         case 1: type = 1; return v(ref_nested());
51481                         ref_nested().clear();
51482                         }
51483                         return false;
51484
51485                 }
51486                 template<typename V> bool encode(size_t index, V& v) const
51487                 {
51488                         if(index != type) {return false;} return v(ref_nested());
51489
51490                 }
51491                 private:
51492                 size_t type {0};
51493
51494         };
51495         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51496         {
51497                 size_t get_index() const {return type;}
51498                 bool is_unknown() const { return type == 1; }
51499                 void clear() {type = 0;}
51500                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51501                 template<typename V>  bool decode(V& v)
51502                 {
51503                         clear();
51504                         if(!v(ref_nested())) return false;
51505                         { type = 1; return true;}
51506                         return false;
51507
51508                 }
51509                 template<typename V> bool encode(V& v) const
51510                 {
51511                         return v(ref_nested());
51512
51513                 }
51514                 protected:
51515                 template<typename V>  bool decode(size_t index, V& v)
51516                 {
51517                         clear();
51518                         switch(index)
51519                         {
51520                         case 1: type = 1; return v(ref_nested());
51521                         ref_nested().clear();
51522                         }
51523                         return false;
51524
51525                 }
51526                 template<typename V> bool encode(size_t index, V& v) const
51527                 {
51528                         if(index != type) {return false;} return v(ref_nested());
51529
51530                 }
51531                 private:
51532                 size_t type {0};
51533
51534         };
51535         struct Extension_t : asn::typefield<true>
51536         {
51537                 ~Extension_t()  {clear();}
51538                 size_t get_index() const {return type;}
51539                 bool is_unknown() const { return type == 1; }
51540                 void clear()
51541                 {
51542                         type = 0; ref_nested().clear();
51543                 }
51544                 template<typename V> static inline void enumerate(V& v)
51545                 {
51546
51547                 }
51548                 protected:
51549                 template<typename V> bool decode(size_t index, V& v)
51550                 {
51551                         clear();
51552                         switch(index)
51553                         {
51554                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51555                         }
51556                         return false;
51557
51558                 }
51559                 template<typename V> bool encode(size_t index, V& v) const
51560                 {
51561                         if(index != type) return false;
51562                         return false;
51563
51564                 }
51565                 private:
51566                 size_t type {0};
51567
51568         };
51569         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51570         {
51571                 size_t get_index() const {return type;}
51572                 bool is_unknown() const { return type == 1; }
51573                 void clear() {type = 0;}
51574                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51575                 template<typename V>  bool decode(V& v)
51576                 {
51577                         clear();
51578                         if(!v(ref_nested())) return false;
51579                         { type = 1; return true;}
51580                         return false;
51581
51582                 }
51583                 template<typename V> bool encode(V& v) const
51584                 {
51585                         return v(ref_nested());
51586
51587                 }
51588                 protected:
51589                 template<typename V>  bool decode(size_t index, V& v)
51590                 {
51591                         clear();
51592                         switch(index)
51593                         {
51594                         case 1: type = 1; return v(ref_nested());
51595                         ref_nested().clear();
51596                         }
51597                         return false;
51598
51599                 }
51600                 template<typename V> bool encode(size_t index, V& v) const
51601                 {
51602                         if(index != type) {return false;} return v(ref_nested());
51603
51604                 }
51605                 private:
51606                 size_t type {0};
51607
51608         };
51609
51610 };
51611 /*
51612 ResponseInformationSgNBReconfComp-SuccessItem ::= SEQUENCE {
51613         meNBtoSgNBContainer                             MeNBtoSgNBContainer                                     OPTIONAL,
51614         iE-Extensions                                   ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-SuccessItemExtIEs} }    OPTIONAL,
51615         ...
51616 }
51617 */
51618
51619 struct ResponseInformationSgNBReconfComp_SuccessItem : asn::sequence<2, 0, true, 2>
51620 {
51621         static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-SuccessItem";}
51622         using parent_t = asn::sequence<2, 0, true, 2>;
51623         struct meNBtoSgNBContainer_t : MeNBtoSgNBContainer
51624         {
51625                 static constexpr const char* name() {return "meNBtoSgNBContainer_t";}
51626                 using parent_t = MeNBtoSgNBContainer;
51627                 static constexpr bool optional = true;
51628
51629         };
51630         meNBtoSgNBContainer_t& set_meNBtoSgNBContainer() { meNBtoSgNBContainer.setpresent(true); return meNBtoSgNBContainer;}
51631         meNBtoSgNBContainer_t const* get_meNBtoSgNBContainer() const {return meNBtoSgNBContainer.is_valid() ? &meNBtoSgNBContainer : nullptr;}
51632         struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>
51633         {
51634                 static constexpr const char* name() {return "iE_Extensions_t";}
51635                 using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_SuccessItemExtIEs>;
51636                 static constexpr bool optional = true;
51637
51638         };
51639         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51640         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51641         template<typename V> void decode(V& v)
51642         {
51643                 v(meNBtoSgNBContainer);
51644                 v(iE_Extensions);
51645
51646         };
51647         template<typename V> void encode(V& v) const
51648         {
51649                 v(meNBtoSgNBContainer);
51650                 v(iE_Extensions);
51651
51652         };
51653         void clear()
51654         {
51655                 meNBtoSgNBContainer.clear();
51656                 iE_Extensions.clear();
51657
51658         };
51659         private:
51660         meNBtoSgNBContainer_t   meNBtoSgNBContainer;
51661         iE_Extensions_t iE_Extensions;
51662
51663 };
51664 /*
51665 ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs X2AP-PROTOCOL-EXTENSION ::= {
51666         ...
51667 }
51668 */
51669
51670 struct ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs
51671 {
51672         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
51673         {
51674                 size_t get_index() const {return type;}
51675                 bool is_unknown() const { return type == 1; }
51676                 void clear() {type = 0;}
51677                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
51678                 template<typename V>  bool decode(V& v)
51679                 {
51680                         clear();
51681                         if(!v(ref_nested())) return false;
51682                         { type = 1; return true;}
51683                         return false;
51684
51685                 }
51686                 template<typename V> bool encode(V& v) const
51687                 {
51688                         return v(ref_nested());
51689
51690                 }
51691                 protected:
51692                 template<typename V>  bool decode(size_t index, V& v)
51693                 {
51694                         clear();
51695                         switch(index)
51696                         {
51697                         case 1: type = 1; return v(ref_nested());
51698                         ref_nested().clear();
51699                         }
51700                         return false;
51701
51702                 }
51703                 template<typename V> bool encode(size_t index, V& v) const
51704                 {
51705                         if(index != type) {return false;} return v(ref_nested());
51706
51707                 }
51708                 private:
51709                 size_t type {0};
51710
51711         };
51712         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
51713         {
51714                 size_t get_index() const {return type;}
51715                 bool is_unknown() const { return type == 1; }
51716                 void clear() {type = 0;}
51717                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
51718                 template<typename V>  bool decode(V& v)
51719                 {
51720                         clear();
51721                         if(!v(ref_nested())) return false;
51722                         { type = 1; return true;}
51723                         return false;
51724
51725                 }
51726                 template<typename V> bool encode(V& v) const
51727                 {
51728                         return v(ref_nested());
51729
51730                 }
51731                 protected:
51732                 template<typename V>  bool decode(size_t index, V& v)
51733                 {
51734                         clear();
51735                         switch(index)
51736                         {
51737                         case 1: type = 1; return v(ref_nested());
51738                         ref_nested().clear();
51739                         }
51740                         return false;
51741
51742                 }
51743                 template<typename V> bool encode(size_t index, V& v) const
51744                 {
51745                         if(index != type) {return false;} return v(ref_nested());
51746
51747                 }
51748                 private:
51749                 size_t type {0};
51750
51751         };
51752         struct Extension_t : asn::typefield<true>
51753         {
51754                 ~Extension_t()  {clear();}
51755                 size_t get_index() const {return type;}
51756                 bool is_unknown() const { return type == 1; }
51757                 void clear()
51758                 {
51759                         type = 0; ref_nested().clear();
51760                 }
51761                 template<typename V> static inline void enumerate(V& v)
51762                 {
51763
51764                 }
51765                 protected:
51766                 template<typename V> bool decode(size_t index, V& v)
51767                 {
51768                         clear();
51769                         switch(index)
51770                         {
51771                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
51772                         }
51773                         return false;
51774
51775                 }
51776                 template<typename V> bool encode(size_t index, V& v) const
51777                 {
51778                         if(index != type) return false;
51779                         return false;
51780
51781                 }
51782                 private:
51783                 size_t type {0};
51784
51785         };
51786         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
51787         {
51788                 size_t get_index() const {return type;}
51789                 bool is_unknown() const { return type == 1; }
51790                 void clear() {type = 0;}
51791                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
51792                 template<typename V>  bool decode(V& v)
51793                 {
51794                         clear();
51795                         if(!v(ref_nested())) return false;
51796                         { type = 1; return true;}
51797                         return false;
51798
51799                 }
51800                 template<typename V> bool encode(V& v) const
51801                 {
51802                         return v(ref_nested());
51803
51804                 }
51805                 protected:
51806                 template<typename V>  bool decode(size_t index, V& v)
51807                 {
51808                         clear();
51809                         switch(index)
51810                         {
51811                         case 1: type = 1; return v(ref_nested());
51812                         ref_nested().clear();
51813                         }
51814                         return false;
51815
51816                 }
51817                 template<typename V> bool encode(size_t index, V& v) const
51818                 {
51819                         if(index != type) {return false;} return v(ref_nested());
51820
51821                 }
51822                 private:
51823                 size_t type {0};
51824
51825         };
51826
51827 };
51828 /*
51829 ResponseInformationSgNBReconfComp-RejectByMeNBItem ::= SEQUENCE {
51830         cause                                                   Cause,
51831         iE-Extensions                                   ProtocolExtensionContainer { {ResponseInformationSgNBReconfComp-RejectByMeNBItemExtIEs} }               OPTIONAL,
51832         ...
51833 }
51834 */
51835
51836 struct ResponseInformationSgNBReconfComp_RejectByMeNBItem : asn::sequence<2, 0, true, 1>
51837 {
51838         static constexpr const char* name() {return "ResponseInformationSgNBReconfComp-RejectByMeNBItem";}
51839         using parent_t = asn::sequence<2, 0, true, 1>;
51840         struct cause_t : Cause
51841         {
51842                 static constexpr const char* name() {return "cause_t";}
51843                 using parent_t = Cause;
51844
51845         };
51846         cause_t& ref_cause() {return cause;}
51847         cause_t const& ref_cause() const {return cause;}
51848         struct iE_Extensions_t : ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>
51849         {
51850                 static constexpr const char* name() {return "iE_Extensions_t";}
51851                 using parent_t = ProtocolExtensionContainer<ResponseInformationSgNBReconfComp_RejectByMeNBItemExtIEs>;
51852                 static constexpr bool optional = true;
51853
51854         };
51855         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
51856         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
51857         template<typename V> void decode(V& v)
51858         {
51859                 v(cause);
51860                 v(iE_Extensions);
51861
51862         };
51863         template<typename V> void encode(V& v) const
51864         {
51865                 v(cause);
51866                 v(iE_Extensions);
51867
51868         };
51869         void clear()
51870         {
51871                 cause.clear();
51872                 iE_Extensions.clear();
51873
51874         };
51875         private:
51876         cause_t cause;
51877         iE_Extensions_t iE_Extensions;
51878
51879 };
51880 /*
51881 ResponseInformationSgNBReconfComp ::= CHOICE {
51882         success-SgNBReconfComp                          ResponseInformationSgNBReconfComp-SuccessItem,
51883         reject-by-MeNB-SgNBReconfComp           ResponseInformationSgNBReconfComp-RejectByMeNBItem,
51884         ...
51885 }
51886 */
51887
51888 struct ResponseInformationSgNBReconfComp : asn::choice<2, 0, true>
51889 {
51890         static constexpr const char* name() {return "ResponseInformationSgNBReconfComp";}
51891         using parent_t = asn::choice<2, 0, true>;
51892         index_type get_index() const {return index;}
51893         bool is_unknown() const {return index == 3;}
51894         void set_unknown() { set_index(3);  }
51895         ~ResponseInformationSgNBReconfComp() {clear();}
51896         struct success_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_SuccessItem
51897         {
51898                 static constexpr const char* name() {return "success_SgNBReconfComp_t";}
51899                 using parent_t = ResponseInformationSgNBReconfComp_SuccessItem;
51900
51901         };
51902         struct reject_by_MeNB_SgNBReconfComp_t : ResponseInformationSgNBReconfComp_RejectByMeNBItem
51903         {
51904                 static constexpr const char* name() {return "reject_by_MeNB_SgNBReconfComp_t";}
51905                 using parent_t = ResponseInformationSgNBReconfComp_RejectByMeNBItem;
51906
51907         };
51908         void clear()
51909         {
51910                 switch(get_index())
51911                 {
51912                 case 1: var.destroy<success_SgNBReconfComp_t>(); break;
51913                 case 2: var.destroy<reject_by_MeNB_SgNBReconfComp_t>(); break;
51914                 }
51915                 index = 0;
51916                 base::clear();
51917         }
51918         template<typename V> bool decode(size_t idx, V& v)
51919         {
51920                 clear();
51921                 switch(idx)
51922                 {
51923                 case 1: set_index(1); return v(var.build<success_SgNBReconfComp_t>());
51924                 case 2: set_index(2); return v(var.build<reject_by_MeNB_SgNBReconfComp_t>());
51925                 }
51926                 return false;
51927
51928         }
51929         template<typename V> bool encode(V& v) const
51930         {
51931                 switch(get_index())
51932                 {
51933                 case 1: return v(var.as<success_SgNBReconfComp_t>());
51934                 case 2: return v(var.as<reject_by_MeNB_SgNBReconfComp_t>());
51935                 }
51936                 return false;
51937         }
51938         template<typename V> static inline void enumerate(V& v)
51939         {
51940                 v.template operator()<success_SgNBReconfComp_t>(1);
51941                 v.template operator()<reject_by_MeNB_SgNBReconfComp_t>(2);
51942
51943         }
51944         success_SgNBReconfComp_t& select_success_SgNBReconfComp() { if(get_index() != 1) { clear(); set_index(1); return var.build<success_SgNBReconfComp_t>();} return var.as<success_SgNBReconfComp_t>();}
51945         success_SgNBReconfComp_t const* get_success_SgNBReconfComp() const { if(get_index() == 1) { return &var.as<success_SgNBReconfComp_t>();} return nullptr; }
51946         reject_by_MeNB_SgNBReconfComp_t& select_reject_by_MeNB_SgNBReconfComp() { if(get_index() != 2) { clear(); set_index(2); return var.build<reject_by_MeNB_SgNBReconfComp_t>();} return var.as<reject_by_MeNB_SgNBReconfComp_t>();}
51947         reject_by_MeNB_SgNBReconfComp_t const* get_reject_by_MeNB_SgNBReconfComp() const { if(get_index() == 2) { return &var.as<reject_by_MeNB_SgNBReconfComp_t>();} return nullptr; }
51948         private:
51949         void set_index(index_type i) {index = i; base::set();}
51950         union union_type
51951         {
51952                 char dummy1[sizeof(success_SgNBReconfComp_t)];
51953                 char dummy2[sizeof(reject_by_MeNB_SgNBReconfComp_t)];
51954
51955         };
51956         asn::variant<sizeof(union_type)>        var;
51957         index_type      index {0};
51958 };
51959 /*
51960 RetrieveUEContextFailure-IEs X2AP-PROTOCOL-IES ::= {
51961         { ID id-New-eNB-UE-X2AP-ID                              CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
51962         { ID id-New-eNB-UE-X2AP-ID-Extension    CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
51963         { ID id-Cause                                                   CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
51964         { ID id-CriticalityDiagnostics                  CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional},
51965         ...
51966 }
51967 */
51968
51969 struct RetrieveUEContextFailure_IEs
51970 {
51971         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
51972         {
51973                 size_t get_index() const {return type;}
51974                 bool is_unknown() const { return type == 5; }
51975                 void clear() {type = 0;}
51976                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
51977                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
51978                 void select_id_Cause() { set(id_Cause); type=3;}
51979                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
51980                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
51981                 template<typename V>  bool decode(V& v)
51982                 {
51983                         clear();
51984                         if(!v(ref_nested())) return false;
51985                         if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
51986                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
51987                         else if(equal(id_Cause)) { type = 3; return true; }
51988                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
51989                         else { type = 5; return true;}
51990                         return false;
51991
51992                 }
51993                 template<typename V> bool encode(V& v) const
51994                 {
51995                         return v(ref_nested());
51996
51997                 }
51998                 protected:
51999                 template<typename V>  bool decode(size_t index, V& v)
52000                 {
52001                         clear();
52002                         switch(index)
52003                         {
52004                         case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
52005                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
52006                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
52007                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
52008                         case 5: type = 5; return v(ref_nested());
52009                         ref_nested().clear();
52010                         }
52011                         return false;
52012
52013                 }
52014                 template<typename V> bool encode(size_t index, V& v) const
52015                 {
52016                         if(index != type) {return false;} return v(ref_nested());
52017
52018                 }
52019                 private:
52020                 size_t type {0};
52021
52022         };
52023         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
52024         {
52025                 size_t get_index() const {return type;}
52026                 bool is_unknown() const { return type == 5; }
52027                 void clear() {type = 0;}
52028                 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
52029                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
52030                 void select_id_Cause() { set(ignore); type=3;}
52031                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
52032                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
52033                 template<typename V>  bool decode(V& v)
52034                 {
52035                         clear();
52036                         if(!v(ref_nested())) return false;
52037                         if(equal(ignore)) { type = 1; return true; }
52038                         else if(equal(ignore)) { type = 2; return true; }
52039                         else if(equal(ignore)) { type = 3; return true; }
52040                         else if(equal(ignore)) { type = 4; return true; }
52041                         else { type = 5; return true;}
52042                         return false;
52043
52044                 }
52045                 template<typename V> bool encode(V& v) const
52046                 {
52047                         return v(ref_nested());
52048
52049                 }
52050                 protected:
52051                 template<typename V>  bool decode(size_t index, V& v)
52052                 {
52053                         clear();
52054                         switch(index)
52055                         {
52056                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
52057                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
52058                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
52059                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
52060                         case 5: type = 5; return v(ref_nested());
52061                         ref_nested().clear();
52062                         }
52063                         return false;
52064
52065                 }
52066                 template<typename V> bool encode(size_t index, V& v) const
52067                 {
52068                         if(index != type) {return false;} return v(ref_nested());
52069
52070                 }
52071                 private:
52072                 size_t type {0};
52073
52074         };
52075         struct Value_t : asn::typefield<true>
52076         {
52077                 ~Value_t()      {clear();}
52078                 size_t get_index() const {return type;}
52079                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
52080                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
52081                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
52082                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
52083                 Cause& select_id_Cause() { return set<Cause>(3); }
52084                 Cause const* get_id_Cause() const { return get<Cause>(3); }
52085                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
52086                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
52087                 bool is_unknown() const { return type == 5; }
52088                 void clear()
52089                 {
52090                         switch(type)
52091                         {
52092                         case 1: var.destroy<UE_X2AP_ID>(); break;
52093                         case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
52094                         case 3: var.destroy<Cause>(); break;
52095                         case 4: var.destroy<CriticalityDiagnostics>(); break;
52096                         }
52097                         type = 0; ref_nested().clear();
52098                 }
52099                 template<typename V> static inline void enumerate(V& v)
52100                 {
52101                         v.template operator()<UE_X2AP_ID>(1);
52102                         v.template operator()<UE_X2AP_ID_Extension>(2);
52103                         v.template operator()<Cause>(3);
52104                         v.template operator()<CriticalityDiagnostics>(4);
52105
52106                 }
52107                 protected:
52108                 template<typename V> bool decode(size_t index, V& v)
52109                 {
52110                         clear();
52111                         switch(index)
52112                         {
52113                         case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
52114                         case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
52115                         case 3: v(select_id_Cause()); return true;
52116                         case 4: v(select_id_CriticalityDiagnostics()); return true;
52117                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
52118                         }
52119                         return false;
52120
52121                 }
52122                 template<typename V> bool encode(size_t index, V& v) const
52123                 {
52124                         if(index != type) return false;
52125                         switch(type)
52126                         {
52127                         case 1: v(var.as<UE_X2AP_ID>()); return true;
52128                         case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
52129                         case 3: v(var.as<Cause>()); return true;
52130                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
52131                         }
52132                         return false;
52133
52134                 }
52135                 private:
52136                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52137                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52138                 union union_type
52139                 {
52140                         char dummy1[sizeof(Cause)];
52141                         char dummy2[sizeof(CriticalityDiagnostics)];
52142                         char dummy3[sizeof(UE_X2AP_ID)];
52143                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
52144
52145                 };
52146                 asn::variant<sizeof(union_type)> var;
52147                 size_t type {0};
52148
52149         };
52150         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
52151         {
52152                 size_t get_index() const {return type;}
52153                 bool is_unknown() const { return type == 5; }
52154                 void clear() {type = 0;}
52155                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
52156                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
52157                 void select_id_Cause() { set(mandatory); type=3;}
52158                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
52159                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
52160                 template<typename V>  bool decode(V& v)
52161                 {
52162                         clear();
52163                         if(!v(ref_nested())) return false;
52164                         if(equal(mandatory)) { type = 1; return true; }
52165                         else if(equal(optional)) { type = 2; return true; }
52166                         else if(equal(mandatory)) { type = 3; return true; }
52167                         else if(equal(optional)) { type = 4; return true; }
52168                         else { type = 5; return true;}
52169                         return false;
52170
52171                 }
52172                 template<typename V> bool encode(V& v) const
52173                 {
52174                         return v(ref_nested());
52175
52176                 }
52177                 protected:
52178                 template<typename V>  bool decode(size_t index, V& v)
52179                 {
52180                         clear();
52181                         switch(index)
52182                         {
52183                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
52184                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
52185                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
52186                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
52187                         case 5: type = 5; return v(ref_nested());
52188                         ref_nested().clear();
52189                         }
52190                         return false;
52191
52192                 }
52193                 template<typename V> bool encode(size_t index, V& v) const
52194                 {
52195                         if(index != type) {return false;} return v(ref_nested());
52196
52197                 }
52198                 private:
52199                 size_t type {0};
52200
52201         };
52202
52203 };
52204 /*
52205 RetrieveUEContextFailure ::= SEQUENCE {
52206         protocolIEs             ProtocolIE-Container    {{ RetrieveUEContextFailure-IEs}},
52207         ...
52208 }
52209 */
52210
52211 struct RetrieveUEContextFailure : asn::sequence<1, 0, true, 0>
52212 {
52213         static constexpr const char* name() {return "RetrieveUEContextFailure";}
52214         using parent_t = asn::sequence<1, 0, true, 0>;
52215         struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextFailure_IEs>
52216         {
52217                 static constexpr const char* name() {return "protocolIEs_t";}
52218                 using parent_t = ProtocolIE_Container<RetrieveUEContextFailure_IEs>;
52219
52220         };
52221         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
52222         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
52223         template<typename V> void decode(V& v)
52224         {
52225                 v(protocolIEs);
52226
52227         };
52228         template<typename V> void encode(V& v) const
52229         {
52230                 v(protocolIEs);
52231
52232         };
52233         void clear()
52234         {
52235                 protocolIEs.clear();
52236
52237         };
52238         private:
52239         protocolIEs_t   protocolIEs;
52240
52241 };
52242 /*
52243 RetrieveUEContextRequest-IEs X2AP-PROTOCOL-IES ::= {
52244         { ID id-New-eNB-UE-X2AP-ID                                      CRITICALITY reject      TYPE UE-X2AP-ID                         PRESENCE mandatory}|
52245         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension       PRESENCE optional}|
52246         { ID id-resumeID                                                        CRITICALITY reject      TYPE ResumeID                           PRESENCE mandatory}|
52247         { ID id-ShortMAC-I                                                      CRITICALITY reject      TYPE ShortMAC-I                         PRESENCE mandatory}|
52248         { ID id-NewEUTRANCellIdentifier                         CRITICALITY reject      TYPE EUTRANCellIdentifier       PRESENCE mandatory}|
52249         {ID id-FailureCellCRNTI                                         CRITICALITY reject      TYPE CRNTI                                      PRESENCE optional}|
52250         {ID id-FailureCellPCI                                           CRITICALITY reject      TYPE PCI                                        PRESENCE optional},
52251         ...
52252 }
52253 */
52254
52255 struct RetrieveUEContextRequest_IEs
52256 {
52257         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
52258         {
52259                 size_t get_index() const {return type;}
52260                 bool is_unknown() const { return type == 8; }
52261                 void clear() {type = 0;}
52262                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
52263                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=2;}
52264                 void select_id_resumeID() { set(id_resumeID); type=3;}
52265                 void select_id_ShortMAC_I() { set(id_ShortMAC_I); type=4;}
52266                 void select_id_NewEUTRANCellIdentifier() { set(id_NewEUTRANCellIdentifier); type=5;}
52267                 void select_id_FailureCellCRNTI() { set(id_FailureCellCRNTI); type=6;}
52268                 void select_id_FailureCellPCI() { set(id_FailureCellPCI); type=7;}
52269                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
52270                 template<typename V>  bool decode(V& v)
52271                 {
52272                         clear();
52273                         if(!v(ref_nested())) return false;
52274                         if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
52275                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
52276                         else if(equal(id_resumeID)) { type = 3; return true; }
52277                         else if(equal(id_ShortMAC_I)) { type = 4; return true; }
52278                         else if(equal(id_NewEUTRANCellIdentifier)) { type = 5; return true; }
52279                         else if(equal(id_FailureCellCRNTI)) { type = 6; return true; }
52280                         else if(equal(id_FailureCellPCI)) { type = 7; return true; }
52281                         else { type = 8; return true;}
52282                         return false;
52283
52284                 }
52285                 template<typename V> bool encode(V& v) const
52286                 {
52287                         return v(ref_nested());
52288
52289                 }
52290                 protected:
52291                 template<typename V>  bool decode(size_t index, V& v)
52292                 {
52293                         clear();
52294                         switch(index)
52295                         {
52296                         case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
52297                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
52298                         case 3: type = 3; if(v(ref_nested())) { return equal(id_resumeID);} return false;
52299                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ShortMAC_I);} return false;
52300                         case 5: type = 5; if(v(ref_nested())) { return equal(id_NewEUTRANCellIdentifier);} return false;
52301                         case 6: type = 6; if(v(ref_nested())) { return equal(id_FailureCellCRNTI);} return false;
52302                         case 7: type = 7; if(v(ref_nested())) { return equal(id_FailureCellPCI);} return false;
52303                         case 8: type = 8; return v(ref_nested());
52304                         ref_nested().clear();
52305                         }
52306                         return false;
52307
52308                 }
52309                 template<typename V> bool encode(size_t index, V& v) const
52310                 {
52311                         if(index != type) {return false;} return v(ref_nested());
52312
52313                 }
52314                 private:
52315                 size_t type {0};
52316
52317         };
52318         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
52319         {
52320                 size_t get_index() const {return type;}
52321                 bool is_unknown() const { return type == 8; }
52322                 void clear() {type = 0;}
52323                 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=1;}
52324                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=2;}
52325                 void select_id_resumeID() { set(reject); type=3;}
52326                 void select_id_ShortMAC_I() { set(reject); type=4;}
52327                 void select_id_NewEUTRANCellIdentifier() { set(reject); type=5;}
52328                 void select_id_FailureCellCRNTI() { set(reject); type=6;}
52329                 void select_id_FailureCellPCI() { set(reject); type=7;}
52330                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
52331                 template<typename V>  bool decode(V& v)
52332                 {
52333                         clear();
52334                         if(!v(ref_nested())) return false;
52335                         if(equal(reject)) { type = 1; return true; }
52336                         else if(equal(reject)) { type = 2; return true; }
52337                         else if(equal(reject)) { type = 3; return true; }
52338                         else if(equal(reject)) { type = 4; return true; }
52339                         else if(equal(reject)) { type = 5; return true; }
52340                         else if(equal(reject)) { type = 6; return true; }
52341                         else if(equal(reject)) { type = 7; return true; }
52342                         else { type = 8; return true;}
52343                         return false;
52344
52345                 }
52346                 template<typename V> bool encode(V& v) const
52347                 {
52348                         return v(ref_nested());
52349
52350                 }
52351                 protected:
52352                 template<typename V>  bool decode(size_t index, V& v)
52353                 {
52354                         clear();
52355                         switch(index)
52356                         {
52357                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
52358                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
52359                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
52360                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
52361                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
52362                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
52363                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
52364                         case 8: type = 8; return v(ref_nested());
52365                         ref_nested().clear();
52366                         }
52367                         return false;
52368
52369                 }
52370                 template<typename V> bool encode(size_t index, V& v) const
52371                 {
52372                         if(index != type) {return false;} return v(ref_nested());
52373
52374                 }
52375                 private:
52376                 size_t type {0};
52377
52378         };
52379         struct Value_t : asn::typefield<true>
52380         {
52381                 ~Value_t()      {clear();}
52382                 size_t get_index() const {return type;}
52383                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
52384                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
52385                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
52386                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
52387                 ResumeID& select_id_resumeID() { return set<ResumeID>(3); }
52388                 ResumeID const* get_id_resumeID() const { return get<ResumeID>(3); }
52389                 ShortMAC_I& select_id_ShortMAC_I() { return set<ShortMAC_I>(4); }
52390                 ShortMAC_I const* get_id_ShortMAC_I() const { return get<ShortMAC_I>(4); }
52391                 EUTRANCellIdentifier& select_id_NewEUTRANCellIdentifier() { return set<EUTRANCellIdentifier>(5); }
52392                 EUTRANCellIdentifier const* get_id_NewEUTRANCellIdentifier() const { return get<EUTRANCellIdentifier>(5); }
52393                 CRNTI& select_id_FailureCellCRNTI() { return set<CRNTI>(6); }
52394                 CRNTI const* get_id_FailureCellCRNTI() const { return get<CRNTI>(6); }
52395                 PCI& select_id_FailureCellPCI() { return set<PCI>(7); }
52396                 PCI const* get_id_FailureCellPCI() const { return get<PCI>(7); }
52397                 bool is_unknown() const { return type == 8; }
52398                 void clear()
52399                 {
52400                         switch(type)
52401                         {
52402                         case 1: var.destroy<UE_X2AP_ID>(); break;
52403                         case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
52404                         case 3: var.destroy<ResumeID>(); break;
52405                         case 4: var.destroy<ShortMAC_I>(); break;
52406                         case 5: var.destroy<EUTRANCellIdentifier>(); break;
52407                         case 6: var.destroy<CRNTI>(); break;
52408                         case 7: var.destroy<PCI>(); break;
52409                         }
52410                         type = 0; ref_nested().clear();
52411                 }
52412                 template<typename V> static inline void enumerate(V& v)
52413                 {
52414                         v.template operator()<UE_X2AP_ID>(1);
52415                         v.template operator()<UE_X2AP_ID_Extension>(2);
52416                         v.template operator()<ResumeID>(3);
52417                         v.template operator()<ShortMAC_I>(4);
52418                         v.template operator()<EUTRANCellIdentifier>(5);
52419                         v.template operator()<CRNTI>(6);
52420                         v.template operator()<PCI>(7);
52421
52422                 }
52423                 protected:
52424                 template<typename V> bool decode(size_t index, V& v)
52425                 {
52426                         clear();
52427                         switch(index)
52428                         {
52429                         case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
52430                         case 2: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
52431                         case 3: v(select_id_resumeID()); return true;
52432                         case 4: v(select_id_ShortMAC_I()); return true;
52433                         case 5: v(select_id_NewEUTRANCellIdentifier()); return true;
52434                         case 6: v(select_id_FailureCellCRNTI()); return true;
52435                         case 7: v(select_id_FailureCellPCI()); return true;
52436                         case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
52437                         }
52438                         return false;
52439
52440                 }
52441                 template<typename V> bool encode(size_t index, V& v) const
52442                 {
52443                         if(index != type) return false;
52444                         switch(type)
52445                         {
52446                         case 1: v(var.as<UE_X2AP_ID>()); return true;
52447                         case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
52448                         case 3: v(var.as<ResumeID>()); return true;
52449                         case 4: v(var.as<ShortMAC_I>()); return true;
52450                         case 5: v(var.as<EUTRANCellIdentifier>()); return true;
52451                         case 6: v(var.as<CRNTI>()); return true;
52452                         case 7: v(var.as<PCI>()); return true;
52453                         }
52454                         return false;
52455
52456                 }
52457                 private:
52458                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52459                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52460                 union union_type
52461                 {
52462                         char dummy1[sizeof(CRNTI)];
52463                         char dummy2[sizeof(EUTRANCellIdentifier)];
52464                         char dummy3[sizeof(PCI)];
52465                         char dummy4[sizeof(ResumeID)];
52466                         char dummy5[sizeof(ShortMAC_I)];
52467                         char dummy6[sizeof(UE_X2AP_ID)];
52468                         char dummy7[sizeof(UE_X2AP_ID_Extension)];
52469
52470                 };
52471                 asn::variant<sizeof(union_type)> var;
52472                 size_t type {0};
52473
52474         };
52475         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
52476         {
52477                 size_t get_index() const {return type;}
52478                 bool is_unknown() const { return type == 8; }
52479                 void clear() {type = 0;}
52480                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
52481                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
52482                 void select_id_resumeID() { set(mandatory); type=3;}
52483                 void select_id_ShortMAC_I() { set(mandatory); type=4;}
52484                 void select_id_NewEUTRANCellIdentifier() { set(mandatory); type=5;}
52485                 void select_id_FailureCellCRNTI() { set(optional); type=6;}
52486                 void select_id_FailureCellPCI() { set(optional); type=7;}
52487                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
52488                 template<typename V>  bool decode(V& v)
52489                 {
52490                         clear();
52491                         if(!v(ref_nested())) return false;
52492                         if(equal(mandatory)) { type = 1; return true; }
52493                         else if(equal(optional)) { type = 2; return true; }
52494                         else if(equal(mandatory)) { type = 3; return true; }
52495                         else if(equal(mandatory)) { type = 4; return true; }
52496                         else if(equal(mandatory)) { type = 5; return true; }
52497                         else if(equal(optional)) { type = 6; return true; }
52498                         else if(equal(optional)) { type = 7; return true; }
52499                         else { type = 8; return true;}
52500                         return false;
52501
52502                 }
52503                 template<typename V> bool encode(V& v) const
52504                 {
52505                         return v(ref_nested());
52506
52507                 }
52508                 protected:
52509                 template<typename V>  bool decode(size_t index, V& v)
52510                 {
52511                         clear();
52512                         switch(index)
52513                         {
52514                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
52515                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
52516                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
52517                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
52518                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
52519                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
52520                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
52521                         case 8: type = 8; return v(ref_nested());
52522                         ref_nested().clear();
52523                         }
52524                         return false;
52525
52526                 }
52527                 template<typename V> bool encode(size_t index, V& v) const
52528                 {
52529                         if(index != type) {return false;} return v(ref_nested());
52530
52531                 }
52532                 private:
52533                 size_t type {0};
52534
52535         };
52536
52537 };
52538 /*
52539 RetrieveUEContextRequest ::= SEQUENCE {
52540         protocolIEs             ProtocolIE-Container    {{ RetrieveUEContextRequest-IEs}},
52541         ...
52542 }
52543 */
52544
52545 struct RetrieveUEContextRequest : asn::sequence<1, 0, true, 0>
52546 {
52547         static constexpr const char* name() {return "RetrieveUEContextRequest";}
52548         using parent_t = asn::sequence<1, 0, true, 0>;
52549         struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextRequest_IEs>
52550         {
52551                 static constexpr const char* name() {return "protocolIEs_t";}
52552                 using parent_t = ProtocolIE_Container<RetrieveUEContextRequest_IEs>;
52553
52554         };
52555         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
52556         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
52557         template<typename V> void decode(V& v)
52558         {
52559                 v(protocolIEs);
52560
52561         };
52562         template<typename V> void encode(V& v) const
52563         {
52564                 v(protocolIEs);
52565
52566         };
52567         void clear()
52568         {
52569                 protocolIEs.clear();
52570
52571         };
52572         private:
52573         protocolIEs_t   protocolIEs;
52574
52575 };
52576 /*
52577 UE-ContextInformationRetrieve-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
52578 { ID id-UESidelinkAggregateMaximumBitRate       CRITICALITY ignore      EXTENSION UESidelinkAggregateMaximumBitRate             PRESENCE optional},
52579         ...
52580 }
52581 */
52582
52583 struct UE_ContextInformationRetrieve_ExtIEs
52584 {
52585         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
52586         {
52587                 size_t get_index() const {return type;}
52588                 bool is_unknown() const { return type == 2; }
52589                 void clear() {type = 0;}
52590                 void select_id_UESidelinkAggregateMaximumBitRate() { set(id_UESidelinkAggregateMaximumBitRate); type=1;}
52591                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
52592                 template<typename V>  bool decode(V& v)
52593                 {
52594                         clear();
52595                         if(!v(ref_nested())) return false;
52596                         if(equal(id_UESidelinkAggregateMaximumBitRate)) { type = 1; return true; }
52597                         else { type = 2; return true;}
52598                         return false;
52599
52600                 }
52601                 template<typename V> bool encode(V& v) const
52602                 {
52603                         return v(ref_nested());
52604
52605                 }
52606                 protected:
52607                 template<typename V>  bool decode(size_t index, V& v)
52608                 {
52609                         clear();
52610                         switch(index)
52611                         {
52612                         case 1: type = 1; if(v(ref_nested())) { return equal(id_UESidelinkAggregateMaximumBitRate);} return false;
52613                         case 2: type = 2; return v(ref_nested());
52614                         ref_nested().clear();
52615                         }
52616                         return false;
52617
52618                 }
52619                 template<typename V> bool encode(size_t index, V& v) const
52620                 {
52621                         if(index != type) {return false;} return v(ref_nested());
52622
52623                 }
52624                 private:
52625                 size_t type {0};
52626
52627         };
52628         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
52629         {
52630                 size_t get_index() const {return type;}
52631                 bool is_unknown() const { return type == 2; }
52632                 void clear() {type = 0;}
52633                 void select_id_UESidelinkAggregateMaximumBitRate() { set(ignore); type=1;}
52634                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
52635                 template<typename V>  bool decode(V& v)
52636                 {
52637                         clear();
52638                         if(!v(ref_nested())) return false;
52639                         if(equal(ignore)) { type = 1; return true; }
52640                         else { type = 2; return true;}
52641                         return false;
52642
52643                 }
52644                 template<typename V> bool encode(V& v) const
52645                 {
52646                         return v(ref_nested());
52647
52648                 }
52649                 protected:
52650                 template<typename V>  bool decode(size_t index, V& v)
52651                 {
52652                         clear();
52653                         switch(index)
52654                         {
52655                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
52656                         case 2: type = 2; return v(ref_nested());
52657                         ref_nested().clear();
52658                         }
52659                         return false;
52660
52661                 }
52662                 template<typename V> bool encode(size_t index, V& v) const
52663                 {
52664                         if(index != type) {return false;} return v(ref_nested());
52665
52666                 }
52667                 private:
52668                 size_t type {0};
52669
52670         };
52671         struct Extension_t : asn::typefield<true>
52672         {
52673                 ~Extension_t()  {clear();}
52674                 size_t get_index() const {return type;}
52675                 UESidelinkAggregateMaximumBitRate& select_id_UESidelinkAggregateMaximumBitRate() { return set<UESidelinkAggregateMaximumBitRate>(1); }
52676                 UESidelinkAggregateMaximumBitRate const* get_id_UESidelinkAggregateMaximumBitRate() const { return get<UESidelinkAggregateMaximumBitRate>(1); }
52677                 bool is_unknown() const { return type == 2; }
52678                 void clear()
52679                 {
52680                         switch(type)
52681                         {
52682                         case 1: var.destroy<UESidelinkAggregateMaximumBitRate>(); break;
52683                         }
52684                         type = 0; ref_nested().clear();
52685                 }
52686                 template<typename V> static inline void enumerate(V& v)
52687                 {
52688                         v.template operator()<UESidelinkAggregateMaximumBitRate>(1);
52689
52690                 }
52691                 protected:
52692                 template<typename V> bool decode(size_t index, V& v)
52693                 {
52694                         clear();
52695                         switch(index)
52696                         {
52697                         case 1: v(select_id_UESidelinkAggregateMaximumBitRate()); return true;
52698                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
52699                         }
52700                         return false;
52701
52702                 }
52703                 template<typename V> bool encode(size_t index, V& v) const
52704                 {
52705                         if(index != type) return false;
52706                         switch(type)
52707                         {
52708                         case 1: v(var.as<UESidelinkAggregateMaximumBitRate>()); return true;
52709                         }
52710                         return false;
52711
52712                 }
52713                 private:
52714                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
52715                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
52716                 union union_type
52717                 {
52718                         char dummy1[sizeof(UESidelinkAggregateMaximumBitRate)];
52719
52720                 };
52721                 asn::variant<sizeof(union_type)> var;
52722                 size_t type {0};
52723
52724         };
52725         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
52726         {
52727                 size_t get_index() const {return type;}
52728                 bool is_unknown() const { return type == 2; }
52729                 void clear() {type = 0;}
52730                 void select_id_UESidelinkAggregateMaximumBitRate() { set(optional); type=1;}
52731                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
52732                 template<typename V>  bool decode(V& v)
52733                 {
52734                         clear();
52735                         if(!v(ref_nested())) return false;
52736                         if(equal(optional)) { type = 1; return true; }
52737                         else { type = 2; return true;}
52738                         return false;
52739
52740                 }
52741                 template<typename V> bool encode(V& v) const
52742                 {
52743                         return v(ref_nested());
52744
52745                 }
52746                 protected:
52747                 template<typename V>  bool decode(size_t index, V& v)
52748                 {
52749                         clear();
52750                         switch(index)
52751                         {
52752                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
52753                         case 2: type = 2; return v(ref_nested());
52754                         ref_nested().clear();
52755                         }
52756                         return false;
52757
52758                 }
52759                 template<typename V> bool encode(size_t index, V& v) const
52760                 {
52761                         if(index != type) {return false;} return v(ref_nested());
52762
52763                 }
52764                 private:
52765                 size_t type {0};
52766
52767         };
52768
52769 };
52770 /*
52771 UE-ContextInformationRetrieve ::= SEQUENCE {
52772         mME-UE-S1AP-ID                                          UE-S1AP-ID,
52773         uESecurityCapabilities                          UESecurityCapabilities,
52774         aS-SecurityInformation                          AS-SecurityInformation,
52775         uEaggregateMaximumBitRate                       UEAggregateMaximumBitRate,
52776         subscriberProfileIDforRFP                       SubscriberProfileIDforRFP               OPTIONAL,
52777         e-RABs-ToBeSetup-ListRetrieve           E-RABs-ToBeSetup-ListRetrieve,
52778         rRC-Context                                                     RRC-Context,
52779         handoverRestrictionList                         HandoverRestrictionList                 OPTIONAL,
52780         locationReportingInformation            LocationReportingInformation    OPTIONAL,
52781         managBasedMDTallowed                            ManagementBasedMDTallowed               OPTIONAL,
52782         managBasedMDTPLMNList                           MDTPLMNList                                             OPTIONAL,
52783         iE-Extensions                                           ProtocolExtensionContainer { {UE-ContextInformationRetrieve-ExtIEs} } OPTIONAL,
52784         ...
52785 }
52786 */
52787
52788 struct UE_ContextInformationRetrieve : asn::sequence<12, 0, true, 6>
52789 {
52790         static constexpr const char* name() {return "UE-ContextInformationRetrieve";}
52791         using parent_t = asn::sequence<12, 0, true, 6>;
52792         struct mME_UE_S1AP_ID_t : UE_S1AP_ID
52793         {
52794                 static constexpr const char* name() {return "mME_UE_S1AP_ID_t";}
52795                 using parent_t = UE_S1AP_ID;
52796
52797         };
52798         mME_UE_S1AP_ID_t& ref_mME_UE_S1AP_ID() {return mME_UE_S1AP_ID;}
52799         mME_UE_S1AP_ID_t const& ref_mME_UE_S1AP_ID() const {return mME_UE_S1AP_ID;}
52800         struct uESecurityCapabilities_t : UESecurityCapabilities
52801         {
52802                 static constexpr const char* name() {return "uESecurityCapabilities_t";}
52803                 using parent_t = UESecurityCapabilities;
52804
52805         };
52806         uESecurityCapabilities_t& ref_uESecurityCapabilities() {return uESecurityCapabilities;}
52807         uESecurityCapabilities_t const& ref_uESecurityCapabilities() const {return uESecurityCapabilities;}
52808         struct aS_SecurityInformation_t : AS_SecurityInformation
52809         {
52810                 static constexpr const char* name() {return "aS_SecurityInformation_t";}
52811                 using parent_t = AS_SecurityInformation;
52812
52813         };
52814         aS_SecurityInformation_t& ref_aS_SecurityInformation() {return aS_SecurityInformation;}
52815         aS_SecurityInformation_t const& ref_aS_SecurityInformation() const {return aS_SecurityInformation;}
52816         struct uEaggregateMaximumBitRate_t : UEAggregateMaximumBitRate
52817         {
52818                 static constexpr const char* name() {return "uEaggregateMaximumBitRate_t";}
52819                 using parent_t = UEAggregateMaximumBitRate;
52820
52821         };
52822         uEaggregateMaximumBitRate_t& ref_uEaggregateMaximumBitRate() {return uEaggregateMaximumBitRate;}
52823         uEaggregateMaximumBitRate_t const& ref_uEaggregateMaximumBitRate() const {return uEaggregateMaximumBitRate;}
52824         struct subscriberProfileIDforRFP_t : SubscriberProfileIDforRFP
52825         {
52826                 static constexpr const char* name() {return "subscriberProfileIDforRFP_t";}
52827                 using parent_t = SubscriberProfileIDforRFP;
52828                 static constexpr bool optional = true;
52829
52830         };
52831         subscriberProfileIDforRFP_t& set_subscriberProfileIDforRFP() { subscriberProfileIDforRFP.setpresent(true); return subscriberProfileIDforRFP;}
52832         subscriberProfileIDforRFP_t const* get_subscriberProfileIDforRFP() const {return subscriberProfileIDforRFP.is_valid() ? &subscriberProfileIDforRFP : nullptr;}
52833         struct e_RABs_ToBeSetup_ListRetrieve_t : E_RABs_ToBeSetup_ListRetrieve
52834         {
52835                 static constexpr const char* name() {return "e_RABs_ToBeSetup_ListRetrieve_t";}
52836                 using parent_t = E_RABs_ToBeSetup_ListRetrieve;
52837
52838         };
52839         e_RABs_ToBeSetup_ListRetrieve_t& ref_e_RABs_ToBeSetup_ListRetrieve() {return e_RABs_ToBeSetup_ListRetrieve;}
52840         e_RABs_ToBeSetup_ListRetrieve_t const& ref_e_RABs_ToBeSetup_ListRetrieve() const {return e_RABs_ToBeSetup_ListRetrieve;}
52841         struct rRC_Context_t : RRC_Context
52842         {
52843                 static constexpr const char* name() {return "rRC_Context_t";}
52844                 using parent_t = RRC_Context;
52845
52846         };
52847         rRC_Context_t& ref_rRC_Context() {return rRC_Context;}
52848         rRC_Context_t const& ref_rRC_Context() const {return rRC_Context;}
52849         struct handoverRestrictionList_t : HandoverRestrictionList
52850         {
52851                 static constexpr const char* name() {return "handoverRestrictionList_t";}
52852                 using parent_t = HandoverRestrictionList;
52853                 static constexpr bool optional = true;
52854
52855         };
52856         handoverRestrictionList_t& set_handoverRestrictionList() { handoverRestrictionList.setpresent(true); return handoverRestrictionList;}
52857         handoverRestrictionList_t const* get_handoverRestrictionList() const {return handoverRestrictionList.is_valid() ? &handoverRestrictionList : nullptr;}
52858         struct locationReportingInformation_t : LocationReportingInformation
52859         {
52860                 static constexpr const char* name() {return "locationReportingInformation_t";}
52861                 using parent_t = LocationReportingInformation;
52862                 static constexpr bool optional = true;
52863
52864         };
52865         locationReportingInformation_t& set_locationReportingInformation() { locationReportingInformation.setpresent(true); return locationReportingInformation;}
52866         locationReportingInformation_t const* get_locationReportingInformation() const {return locationReportingInformation.is_valid() ? &locationReportingInformation : nullptr;}
52867         struct managBasedMDTallowed_t : ManagementBasedMDTallowed
52868         {
52869                 static constexpr const char* name() {return "managBasedMDTallowed_t";}
52870                 using parent_t = ManagementBasedMDTallowed;
52871                 static constexpr bool optional = true;
52872
52873         };
52874         managBasedMDTallowed_t& set_managBasedMDTallowed() { managBasedMDTallowed.setpresent(true); return managBasedMDTallowed;}
52875         managBasedMDTallowed_t const* get_managBasedMDTallowed() const {return managBasedMDTallowed.is_valid() ? &managBasedMDTallowed : nullptr;}
52876         struct managBasedMDTPLMNList_t : MDTPLMNList
52877         {
52878                 static constexpr const char* name() {return "managBasedMDTPLMNList_t";}
52879                 using parent_t = MDTPLMNList;
52880                 static constexpr bool optional = true;
52881
52882         };
52883         managBasedMDTPLMNList_t& set_managBasedMDTPLMNList() { managBasedMDTPLMNList.setpresent(true); return managBasedMDTPLMNList;}
52884         managBasedMDTPLMNList_t const* get_managBasedMDTPLMNList() const {return managBasedMDTPLMNList.is_valid() ? &managBasedMDTPLMNList : nullptr;}
52885         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationRetrieve_ExtIEs>
52886         {
52887                 static constexpr const char* name() {return "iE_Extensions_t";}
52888                 using parent_t = ProtocolExtensionContainer<UE_ContextInformationRetrieve_ExtIEs>;
52889                 static constexpr bool optional = true;
52890
52891         };
52892         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
52893         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
52894         template<typename V> void decode(V& v)
52895         {
52896                 v(mME_UE_S1AP_ID);
52897                 v(uESecurityCapabilities);
52898                 v(aS_SecurityInformation);
52899                 v(uEaggregateMaximumBitRate);
52900                 v(subscriberProfileIDforRFP);
52901                 v(e_RABs_ToBeSetup_ListRetrieve);
52902                 v(rRC_Context);
52903                 v(handoverRestrictionList);
52904                 v(locationReportingInformation);
52905                 v(managBasedMDTallowed);
52906                 v(managBasedMDTPLMNList);
52907                 v(iE_Extensions);
52908
52909         };
52910         template<typename V> void encode(V& v) const
52911         {
52912                 v(mME_UE_S1AP_ID);
52913                 v(uESecurityCapabilities);
52914                 v(aS_SecurityInformation);
52915                 v(uEaggregateMaximumBitRate);
52916                 v(subscriberProfileIDforRFP);
52917                 v(e_RABs_ToBeSetup_ListRetrieve);
52918                 v(rRC_Context);
52919                 v(handoverRestrictionList);
52920                 v(locationReportingInformation);
52921                 v(managBasedMDTallowed);
52922                 v(managBasedMDTPLMNList);
52923                 v(iE_Extensions);
52924
52925         };
52926         void clear()
52927         {
52928                 mME_UE_S1AP_ID.clear();
52929                 uESecurityCapabilities.clear();
52930                 aS_SecurityInformation.clear();
52931                 uEaggregateMaximumBitRate.clear();
52932                 subscriberProfileIDforRFP.clear();
52933                 e_RABs_ToBeSetup_ListRetrieve.clear();
52934                 rRC_Context.clear();
52935                 handoverRestrictionList.clear();
52936                 locationReportingInformation.clear();
52937                 managBasedMDTallowed.clear();
52938                 managBasedMDTPLMNList.clear();
52939                 iE_Extensions.clear();
52940
52941         };
52942         private:
52943         mME_UE_S1AP_ID_t        mME_UE_S1AP_ID;
52944         uESecurityCapabilities_t        uESecurityCapabilities;
52945         aS_SecurityInformation_t        aS_SecurityInformation;
52946         uEaggregateMaximumBitRate_t     uEaggregateMaximumBitRate;
52947         subscriberProfileIDforRFP_t     subscriberProfileIDforRFP;
52948         e_RABs_ToBeSetup_ListRetrieve_t e_RABs_ToBeSetup_ListRetrieve;
52949         rRC_Context_t   rRC_Context;
52950         handoverRestrictionList_t       handoverRestrictionList;
52951         locationReportingInformation_t  locationReportingInformation;
52952         managBasedMDTallowed_t  managBasedMDTallowed;
52953         managBasedMDTPLMNList_t managBasedMDTPLMNList;
52954         iE_Extensions_t iE_Extensions;
52955
52956 };
52957 /*
52958 RetrieveUEContextResponse-IEs X2AP-PROTOCOL-IES ::= {
52959         { ID id-New-eNB-UE-X2AP-ID                              CRITICALITY ignore      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
52960         { ID id-New-eNB-UE-X2AP-ID-Extension    CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
52961         { ID id-Old-eNB-UE-X2AP-ID                              CRITICALITY ignore      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
52962         { ID id-Old-eNB-UE-X2AP-ID-Extension    CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
52963         { ID id-GUMMEI-ID                                               CRITICALITY reject      TYPE GUMMEI                                                             PRESENCE mandatory}|
52964         { ID id-UE-ContextInformationRetrieve   CRITICALITY reject      TYPE UE-ContextInformationRetrieve      PRESENCE mandatory}|
52965         { ID id-TraceActivation                                 CRITICALITY ignore      TYPE TraceActivation                                    PRESENCE optional}|
52966         { ID id-SRVCCOperationPossible                  CRITICALITY ignore      TYPE SRVCCOperationPossible                             PRESENCE optional}|
52967         { ID id-Masked-IMEISV                                   CRITICALITY ignore      TYPE Masked-IMEISV                                              PRESENCE optional}|
52968         { ID id-ExpectedUEBehaviour                             CRITICALITY ignore      TYPE ExpectedUEBehaviour                                PRESENCE optional}|
52969         { ID id-ProSeAuthorized                                 CRITICALITY ignore      TYPE ProSeAuthorized                                    PRESENCE optional}|
52970         { ID id-CriticalityDiagnostics                  CRITICALITY ignore      TYPE CriticalityDiagnostics                             PRESENCE optional}|
52971         { ID id-V2XServicesAuthorized                   CRITICALITY ignore      TYPE V2XServicesAuthorized                              PRESENCE optional}|
52972         { ID id-AerialUEsubscriptionInformation CRITICALITY ignore      TYPE AerialUEsubscriptionInformation    PRESENCE optional}|
52973         { ID id-Subscription-Based-UE-DifferentiationInfo                       CRITICALITY ignore      TYPE Subscription-Based-UE-DifferentiationInfo                          PRESENCE optional},
52974         ...
52975 }
52976 */
52977
52978 struct RetrieveUEContextResponse_IEs
52979 {
52980         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
52981         {
52982                 size_t get_index() const {return type;}
52983                 bool is_unknown() const { return type == 16; }
52984                 void clear() {type = 0;}
52985                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=1;}
52986                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=2;}
52987                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=3;}
52988                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
52989                 void select_id_GUMMEI_ID() { set(id_GUMMEI_ID); type=5;}
52990                 void select_id_UE_ContextInformationRetrieve() { set(id_UE_ContextInformationRetrieve); type=6;}
52991                 void select_id_TraceActivation() { set(id_TraceActivation); type=7;}
52992                 void select_id_SRVCCOperationPossible() { set(id_SRVCCOperationPossible); type=8;}
52993                 void select_id_Masked_IMEISV() { set(id_Masked_IMEISV); type=9;}
52994                 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
52995                 void select_id_ProSeAuthorized() { set(id_ProSeAuthorized); type=11;}
52996                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=12;}
52997                 void select_id_V2XServicesAuthorized() { set(id_V2XServicesAuthorized); type=13;}
52998                 void select_id_AerialUEsubscriptionInformation() { set(id_AerialUEsubscriptionInformation); type=14;}
52999                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(id_Subscription_Based_UE_DifferentiationInfo); type=15;}
53000                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53001                 template<typename V>  bool decode(V& v)
53002                 {
53003                         clear();
53004                         if(!v(ref_nested())) return false;
53005                         if(equal(id_New_eNB_UE_X2AP_ID)) { type = 1; return true; }
53006                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 2; return true; }
53007                         else if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 3; return true; }
53008                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
53009                         else if(equal(id_GUMMEI_ID)) { type = 5; return true; }
53010                         else if(equal(id_UE_ContextInformationRetrieve)) { type = 6; return true; }
53011                         else if(equal(id_TraceActivation)) { type = 7; return true; }
53012                         else if(equal(id_SRVCCOperationPossible)) { type = 8; return true; }
53013                         else if(equal(id_Masked_IMEISV)) { type = 9; return true; }
53014                         else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
53015                         else if(equal(id_ProSeAuthorized)) { type = 11; return true; }
53016                         else if(equal(id_CriticalityDiagnostics)) { type = 12; return true; }
53017                         else if(equal(id_V2XServicesAuthorized)) { type = 13; return true; }
53018                         else if(equal(id_AerialUEsubscriptionInformation)) { type = 14; return true; }
53019                         else if(equal(id_Subscription_Based_UE_DifferentiationInfo)) { type = 15; return true; }
53020                         else { type = 16; return true;}
53021                         return false;
53022
53023                 }
53024                 template<typename V> bool encode(V& v) const
53025                 {
53026                         return v(ref_nested());
53027
53028                 }
53029                 protected:
53030                 template<typename V>  bool decode(size_t index, V& v)
53031                 {
53032                         clear();
53033                         switch(index)
53034                         {
53035                         case 1: type = 1; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
53036                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
53037                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
53038                         case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
53039                         case 5: type = 5; if(v(ref_nested())) { return equal(id_GUMMEI_ID);} return false;
53040                         case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationRetrieve);} return false;
53041                         case 7: type = 7; if(v(ref_nested())) { return equal(id_TraceActivation);} return false;
53042                         case 8: type = 8; if(v(ref_nested())) { return equal(id_SRVCCOperationPossible);} return false;
53043                         case 9: type = 9; if(v(ref_nested())) { return equal(id_Masked_IMEISV);} return false;
53044                         case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
53045                         case 11: type = 11; if(v(ref_nested())) { return equal(id_ProSeAuthorized);} return false;
53046                         case 12: type = 12; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
53047                         case 13: type = 13; if(v(ref_nested())) { return equal(id_V2XServicesAuthorized);} return false;
53048                         case 14: type = 14; if(v(ref_nested())) { return equal(id_AerialUEsubscriptionInformation);} return false;
53049                         case 15: type = 15; if(v(ref_nested())) { return equal(id_Subscription_Based_UE_DifferentiationInfo);} return false;
53050                         case 16: type = 16; return v(ref_nested());
53051                         ref_nested().clear();
53052                         }
53053                         return false;
53054
53055                 }
53056                 template<typename V> bool encode(size_t index, V& v) const
53057                 {
53058                         if(index != type) {return false;} return v(ref_nested());
53059
53060                 }
53061                 private:
53062                 size_t type {0};
53063
53064         };
53065         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53066         {
53067                 size_t get_index() const {return type;}
53068                 bool is_unknown() const { return type == 16; }
53069                 void clear() {type = 0;}
53070                 void select_id_New_eNB_UE_X2AP_ID() { set(ignore); type=1;}
53071                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(ignore); type=2;}
53072                 void select_id_Old_eNB_UE_X2AP_ID() { set(ignore); type=3;}
53073                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
53074                 void select_id_GUMMEI_ID() { set(reject); type=5;}
53075                 void select_id_UE_ContextInformationRetrieve() { set(reject); type=6;}
53076                 void select_id_TraceActivation() { set(ignore); type=7;}
53077                 void select_id_SRVCCOperationPossible() { set(ignore); type=8;}
53078                 void select_id_Masked_IMEISV() { set(ignore); type=9;}
53079                 void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
53080                 void select_id_ProSeAuthorized() { set(ignore); type=11;}
53081                 void select_id_CriticalityDiagnostics() { set(ignore); type=12;}
53082                 void select_id_V2XServicesAuthorized() { set(ignore); type=13;}
53083                 void select_id_AerialUEsubscriptionInformation() { set(ignore); type=14;}
53084                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(ignore); type=15;}
53085                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53086                 template<typename V>  bool decode(V& v)
53087                 {
53088                         clear();
53089                         if(!v(ref_nested())) return false;
53090                         if(equal(ignore)) { type = 1; return true; }
53091                         else if(equal(ignore)) { type = 2; return true; }
53092                         else if(equal(ignore)) { type = 3; return true; }
53093                         else if(equal(ignore)) { type = 4; return true; }
53094                         else if(equal(reject)) { type = 5; return true; }
53095                         else if(equal(reject)) { type = 6; return true; }
53096                         else if(equal(ignore)) { type = 7; return true; }
53097                         else if(equal(ignore)) { type = 8; return true; }
53098                         else if(equal(ignore)) { type = 9; return true; }
53099                         else if(equal(ignore)) { type = 10; return true; }
53100                         else if(equal(ignore)) { type = 11; return true; }
53101                         else if(equal(ignore)) { type = 12; return true; }
53102                         else if(equal(ignore)) { type = 13; return true; }
53103                         else if(equal(ignore)) { type = 14; return true; }
53104                         else if(equal(ignore)) { type = 15; return true; }
53105                         else { type = 16; return true;}
53106                         return false;
53107
53108                 }
53109                 template<typename V> bool encode(V& v) const
53110                 {
53111                         return v(ref_nested());
53112
53113                 }
53114                 protected:
53115                 template<typename V>  bool decode(size_t index, V& v)
53116                 {
53117                         clear();
53118                         switch(index)
53119                         {
53120                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
53121                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
53122                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
53123                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
53124                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
53125                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
53126                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
53127                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
53128                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
53129                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
53130                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
53131                         case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
53132                         case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
53133                         case 14: type = 14; if(v(ref_nested())) { return equal(ignore);} return false;
53134                         case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
53135                         case 16: type = 16; return v(ref_nested());
53136                         ref_nested().clear();
53137                         }
53138                         return false;
53139
53140                 }
53141                 template<typename V> bool encode(size_t index, V& v) const
53142                 {
53143                         if(index != type) {return false;} return v(ref_nested());
53144
53145                 }
53146                 private:
53147                 size_t type {0};
53148
53149         };
53150         struct Value_t : asn::typefield<true>
53151         {
53152                 ~Value_t()      {clear();}
53153                 size_t get_index() const {return type;}
53154                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53155                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53156                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(2); }
53157                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(2); }
53158                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(3); }
53159                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(3); }
53160                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
53161                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
53162                 GUMMEI& select_id_GUMMEI_ID() { return set<GUMMEI>(5); }
53163                 GUMMEI const* get_id_GUMMEI_ID() const { return get<GUMMEI>(5); }
53164                 UE_ContextInformationRetrieve& select_id_UE_ContextInformationRetrieve() { return set<UE_ContextInformationRetrieve>(6); }
53165                 UE_ContextInformationRetrieve const* get_id_UE_ContextInformationRetrieve() const { return get<UE_ContextInformationRetrieve>(6); }
53166                 TraceActivation& select_id_TraceActivation() { return set<TraceActivation>(7); }
53167                 TraceActivation const* get_id_TraceActivation() const { return get<TraceActivation>(7); }
53168                 SRVCCOperationPossible& select_id_SRVCCOperationPossible() { return set<SRVCCOperationPossible>(8); }
53169                 SRVCCOperationPossible const* get_id_SRVCCOperationPossible() const { return get<SRVCCOperationPossible>(8); }
53170                 Masked_IMEISV& select_id_Masked_IMEISV() { return set<Masked_IMEISV>(9); }
53171                 Masked_IMEISV const* get_id_Masked_IMEISV() const { return get<Masked_IMEISV>(9); }
53172                 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
53173                 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
53174                 ProSeAuthorized& select_id_ProSeAuthorized() { return set<ProSeAuthorized>(11); }
53175                 ProSeAuthorized const* get_id_ProSeAuthorized() const { return get<ProSeAuthorized>(11); }
53176                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(12); }
53177                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(12); }
53178                 V2XServicesAuthorized& select_id_V2XServicesAuthorized() { return set<V2XServicesAuthorized>(13); }
53179                 V2XServicesAuthorized const* get_id_V2XServicesAuthorized() const { return get<V2XServicesAuthorized>(13); }
53180                 AerialUEsubscriptionInformation& select_id_AerialUEsubscriptionInformation() { return set<AerialUEsubscriptionInformation>(14); }
53181                 AerialUEsubscriptionInformation const* get_id_AerialUEsubscriptionInformation() const { return get<AerialUEsubscriptionInformation>(14); }
53182                 Subscription_Based_UE_DifferentiationInfo& select_id_Subscription_Based_UE_DifferentiationInfo() { return set<Subscription_Based_UE_DifferentiationInfo>(15); }
53183                 Subscription_Based_UE_DifferentiationInfo const* get_id_Subscription_Based_UE_DifferentiationInfo() const { return get<Subscription_Based_UE_DifferentiationInfo>(15); }
53184                 bool is_unknown() const { return type == 16; }
53185                 void clear()
53186                 {
53187                         switch(type)
53188                         {
53189                         case 1: var.destroy<UE_X2AP_ID>(); break;
53190                         case 2: var.destroy<UE_X2AP_ID_Extension>(); break;
53191                         case 3: var.destroy<UE_X2AP_ID>(); break;
53192                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
53193                         case 5: var.destroy<GUMMEI>(); break;
53194                         case 6: var.destroy<UE_ContextInformationRetrieve>(); break;
53195                         case 7: var.destroy<TraceActivation>(); break;
53196                         case 8: var.destroy<SRVCCOperationPossible>(); break;
53197                         case 9: var.destroy<Masked_IMEISV>(); break;
53198                         case 10: var.destroy<ExpectedUEBehaviour>(); break;
53199                         case 11: var.destroy<ProSeAuthorized>(); break;
53200                         case 12: var.destroy<CriticalityDiagnostics>(); break;
53201                         case 13: var.destroy<V2XServicesAuthorized>(); break;
53202                         case 14: var.destroy<AerialUEsubscriptionInformation>(); break;
53203                         case 15: var.destroy<Subscription_Based_UE_DifferentiationInfo>(); break;
53204                         }
53205                         type = 0; ref_nested().clear();
53206                 }
53207                 template<typename V> static inline void enumerate(V& v)
53208                 {
53209                         v.template operator()<UE_X2AP_ID>(1);
53210                         v.template operator()<UE_X2AP_ID_Extension>(2);
53211                         v.template operator()<UE_X2AP_ID>(3);
53212                         v.template operator()<UE_X2AP_ID_Extension>(4);
53213                         v.template operator()<GUMMEI>(5);
53214                         v.template operator()<UE_ContextInformationRetrieve>(6);
53215                         v.template operator()<TraceActivation>(7);
53216                         v.template operator()<SRVCCOperationPossible>(8);
53217                         v.template operator()<Masked_IMEISV>(9);
53218                         v.template operator()<ExpectedUEBehaviour>(10);
53219                         v.template operator()<ProSeAuthorized>(11);
53220                         v.template operator()<CriticalityDiagnostics>(12);
53221                         v.template operator()<V2XServicesAuthorized>(13);
53222                         v.template operator()<AerialUEsubscriptionInformation>(14);
53223                         v.template operator()<Subscription_Based_UE_DifferentiationInfo>(15);
53224
53225                 }
53226                 protected:
53227                 template<typename V> bool decode(size_t index, V& v)
53228                 {
53229                         clear();
53230                         switch(index)
53231                         {
53232                         case 1: v(select_id_New_eNB_UE_X2AP_ID()); return true;
53233                         case 2: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
53234                         case 3: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
53235                         case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
53236                         case 5: v(select_id_GUMMEI_ID()); return true;
53237                         case 6: v(select_id_UE_ContextInformationRetrieve()); return true;
53238                         case 7: v(select_id_TraceActivation()); return true;
53239                         case 8: v(select_id_SRVCCOperationPossible()); return true;
53240                         case 9: v(select_id_Masked_IMEISV()); return true;
53241                         case 10: v(select_id_ExpectedUEBehaviour()); return true;
53242                         case 11: v(select_id_ProSeAuthorized()); return true;
53243                         case 12: v(select_id_CriticalityDiagnostics()); return true;
53244                         case 13: v(select_id_V2XServicesAuthorized()); return true;
53245                         case 14: v(select_id_AerialUEsubscriptionInformation()); return true;
53246                         case 15: v(select_id_Subscription_Based_UE_DifferentiationInfo()); return true;
53247                         case 16: if(type != 16) {clear(); asn::base::set();} type = 16; return true;
53248                         }
53249                         return false;
53250
53251                 }
53252                 template<typename V> bool encode(size_t index, V& v) const
53253                 {
53254                         if(index != type) return false;
53255                         switch(type)
53256                         {
53257                         case 1: v(var.as<UE_X2AP_ID>()); return true;
53258                         case 2: v(var.as<UE_X2AP_ID_Extension>()); return true;
53259                         case 3: v(var.as<UE_X2AP_ID>()); return true;
53260                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
53261                         case 5: v(var.as<GUMMEI>()); return true;
53262                         case 6: v(var.as<UE_ContextInformationRetrieve>()); return true;
53263                         case 7: v(var.as<TraceActivation>()); return true;
53264                         case 8: v(var.as<SRVCCOperationPossible>()); return true;
53265                         case 9: v(var.as<Masked_IMEISV>()); return true;
53266                         case 10: v(var.as<ExpectedUEBehaviour>()); return true;
53267                         case 11: v(var.as<ProSeAuthorized>()); return true;
53268                         case 12: v(var.as<CriticalityDiagnostics>()); return true;
53269                         case 13: v(var.as<V2XServicesAuthorized>()); return true;
53270                         case 14: v(var.as<AerialUEsubscriptionInformation>()); return true;
53271                         case 15: v(var.as<Subscription_Based_UE_DifferentiationInfo>()); return true;
53272                         }
53273                         return false;
53274
53275                 }
53276                 private:
53277                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
53278                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
53279                 union union_type
53280                 {
53281                         char dummy1[sizeof(AerialUEsubscriptionInformation)];
53282                         char dummy2[sizeof(CriticalityDiagnostics)];
53283                         char dummy3[sizeof(ExpectedUEBehaviour)];
53284                         char dummy4[sizeof(GUMMEI)];
53285                         char dummy5[sizeof(Masked_IMEISV)];
53286                         char dummy6[sizeof(ProSeAuthorized)];
53287                         char dummy7[sizeof(SRVCCOperationPossible)];
53288                         char dummy8[sizeof(Subscription_Based_UE_DifferentiationInfo)];
53289                         char dummy9[sizeof(TraceActivation)];
53290                         char dummy10[sizeof(UE_ContextInformationRetrieve)];
53291                         char dummy11[sizeof(UE_X2AP_ID)];
53292                         char dummy12[sizeof(UE_X2AP_ID_Extension)];
53293                         char dummy13[sizeof(V2XServicesAuthorized)];
53294
53295                 };
53296                 asn::variant<sizeof(union_type)> var;
53297                 size_t type {0};
53298
53299         };
53300         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
53301         {
53302                 size_t get_index() const {return type;}
53303                 bool is_unknown() const { return type == 16; }
53304                 void clear() {type = 0;}
53305                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
53306                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=2;}
53307                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=3;}
53308                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
53309                 void select_id_GUMMEI_ID() { set(mandatory); type=5;}
53310                 void select_id_UE_ContextInformationRetrieve() { set(mandatory); type=6;}
53311                 void select_id_TraceActivation() { set(optional); type=7;}
53312                 void select_id_SRVCCOperationPossible() { set(optional); type=8;}
53313                 void select_id_Masked_IMEISV() { set(optional); type=9;}
53314                 void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
53315                 void select_id_ProSeAuthorized() { set(optional); type=11;}
53316                 void select_id_CriticalityDiagnostics() { set(optional); type=12;}
53317                 void select_id_V2XServicesAuthorized() { set(optional); type=13;}
53318                 void select_id_AerialUEsubscriptionInformation() { set(optional); type=14;}
53319                 void select_id_Subscription_Based_UE_DifferentiationInfo() { set(optional); type=15;}
53320                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
53321                 template<typename V>  bool decode(V& v)
53322                 {
53323                         clear();
53324                         if(!v(ref_nested())) return false;
53325                         if(equal(mandatory)) { type = 1; return true; }
53326                         else if(equal(optional)) { type = 2; return true; }
53327                         else if(equal(mandatory)) { type = 3; return true; }
53328                         else if(equal(optional)) { type = 4; return true; }
53329                         else if(equal(mandatory)) { type = 5; return true; }
53330                         else if(equal(mandatory)) { type = 6; return true; }
53331                         else if(equal(optional)) { type = 7; return true; }
53332                         else if(equal(optional)) { type = 8; return true; }
53333                         else if(equal(optional)) { type = 9; return true; }
53334                         else if(equal(optional)) { type = 10; return true; }
53335                         else if(equal(optional)) { type = 11; return true; }
53336                         else if(equal(optional)) { type = 12; return true; }
53337                         else if(equal(optional)) { type = 13; return true; }
53338                         else if(equal(optional)) { type = 14; return true; }
53339                         else if(equal(optional)) { type = 15; return true; }
53340                         else { type = 16; return true;}
53341                         return false;
53342
53343                 }
53344                 template<typename V> bool encode(V& v) const
53345                 {
53346                         return v(ref_nested());
53347
53348                 }
53349                 protected:
53350                 template<typename V>  bool decode(size_t index, V& v)
53351                 {
53352                         clear();
53353                         switch(index)
53354                         {
53355                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
53356                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
53357                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
53358                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
53359                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
53360                         case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
53361                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
53362                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
53363                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
53364                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
53365                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
53366                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
53367                         case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
53368                         case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
53369                         case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
53370                         case 16: type = 16; return v(ref_nested());
53371                         ref_nested().clear();
53372                         }
53373                         return false;
53374
53375                 }
53376                 template<typename V> bool encode(size_t index, V& v) const
53377                 {
53378                         if(index != type) {return false;} return v(ref_nested());
53379
53380                 }
53381                 private:
53382                 size_t type {0};
53383
53384         };
53385
53386 };
53387 /*
53388 RetrieveUEContextResponse ::= SEQUENCE {
53389         protocolIEs                     ProtocolIE-Container    {{ RetrieveUEContextResponse-IEs}},
53390         ...
53391 }
53392 */
53393
53394 struct RetrieveUEContextResponse : asn::sequence<1, 0, true, 0>
53395 {
53396         static constexpr const char* name() {return "RetrieveUEContextResponse";}
53397         using parent_t = asn::sequence<1, 0, true, 0>;
53398         struct protocolIEs_t : ProtocolIE_Container<RetrieveUEContextResponse_IEs>
53399         {
53400                 static constexpr const char* name() {return "protocolIEs_t";}
53401                 using parent_t = ProtocolIE_Container<RetrieveUEContextResponse_IEs>;
53402
53403         };
53404         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
53405         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
53406         template<typename V> void decode(V& v)
53407         {
53408                 v(protocolIEs);
53409
53410         };
53411         template<typename V> void encode(V& v) const
53412         {
53413                 v(protocolIEs);
53414
53415         };
53416         void clear()
53417         {
53418                 protocolIEs.clear();
53419
53420         };
53421         private:
53422         protocolIEs_t   protocolIEs;
53423
53424 };
53425 /*
53426 SNStatusTransfer-IEs X2AP-PROTOCOL-IES ::= {
53427         { ID id-Old-eNB-UE-X2AP-ID                                              CRITICALITY reject      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
53428         { ID id-New-eNB-UE-X2AP-ID                                              CRITICALITY reject      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
53429         { ID id-E-RABs-SubjectToStatusTransfer-List             CRITICALITY ignore      TYPE E-RABs-SubjectToStatusTransfer-List                PRESENCE mandatory}|
53430         { ID id-Old-eNB-UE-X2AP-ID-Extension                    CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
53431         { ID id-New-eNB-UE-X2AP-ID-Extension                    CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
53432         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE optional},
53433         ...
53434 }
53435 */
53436
53437 struct SNStatusTransfer_IEs
53438 {
53439         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
53440         {
53441                 size_t get_index() const {return type;}
53442                 bool is_unknown() const { return type == 7; }
53443                 void clear() {type = 0;}
53444                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
53445                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
53446                 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(id_E_RABs_SubjectToStatusTransfer_List); type=3;}
53447                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=4;}
53448                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=5;}
53449                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
53450                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53451                 template<typename V>  bool decode(V& v)
53452                 {
53453                         clear();
53454                         if(!v(ref_nested())) return false;
53455                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
53456                         else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
53457                         else if(equal(id_E_RABs_SubjectToStatusTransfer_List)) { type = 3; return true; }
53458                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
53459                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
53460                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 6; return true; }
53461                         else { type = 7; return true;}
53462                         return false;
53463
53464                 }
53465                 template<typename V> bool encode(V& v) const
53466                 {
53467                         return v(ref_nested());
53468
53469                 }
53470                 protected:
53471                 template<typename V>  bool decode(size_t index, V& v)
53472                 {
53473                         clear();
53474                         switch(index)
53475                         {
53476                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
53477                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
53478                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToStatusTransfer_List);} return false;
53479                         case 4: type = 4; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
53480                         case 5: type = 5; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
53481                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
53482                         case 7: type = 7; return v(ref_nested());
53483                         ref_nested().clear();
53484                         }
53485                         return false;
53486
53487                 }
53488                 template<typename V> bool encode(size_t index, V& v) const
53489                 {
53490                         if(index != type) {return false;} return v(ref_nested());
53491
53492                 }
53493                 private:
53494                 size_t type {0};
53495
53496         };
53497         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53498         {
53499                 size_t get_index() const {return type;}
53500                 bool is_unknown() const { return type == 7; }
53501                 void clear() {type = 0;}
53502                 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
53503                 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
53504                 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(ignore); type=3;}
53505                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
53506                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
53507                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
53508                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53509                 template<typename V>  bool decode(V& v)
53510                 {
53511                         clear();
53512                         if(!v(ref_nested())) return false;
53513                         if(equal(reject)) { type = 1; return true; }
53514                         else if(equal(reject)) { type = 2; return true; }
53515                         else if(equal(ignore)) { type = 3; return true; }
53516                         else if(equal(reject)) { type = 4; return true; }
53517                         else if(equal(reject)) { type = 5; return true; }
53518                         else if(equal(ignore)) { type = 6; return true; }
53519                         else { type = 7; return true;}
53520                         return false;
53521
53522                 }
53523                 template<typename V> bool encode(V& v) const
53524                 {
53525                         return v(ref_nested());
53526
53527                 }
53528                 protected:
53529                 template<typename V>  bool decode(size_t index, V& v)
53530                 {
53531                         clear();
53532                         switch(index)
53533                         {
53534                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
53535                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
53536                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
53537                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
53538                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
53539                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
53540                         case 7: type = 7; return v(ref_nested());
53541                         ref_nested().clear();
53542                         }
53543                         return false;
53544
53545                 }
53546                 template<typename V> bool encode(size_t index, V& v) const
53547                 {
53548                         if(index != type) {return false;} return v(ref_nested());
53549
53550                 }
53551                 private:
53552                 size_t type {0};
53553
53554         };
53555         struct Value_t : asn::typefield<true>
53556         {
53557                 ~Value_t()      {clear();}
53558                 size_t get_index() const {return type;}
53559                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53560                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53561                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
53562                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
53563                 E_RABs_SubjectToStatusTransfer_List& select_id_E_RABs_SubjectToStatusTransfer_List() { return set<E_RABs_SubjectToStatusTransfer_List>(3); }
53564                 E_RABs_SubjectToStatusTransfer_List const* get_id_E_RABs_SubjectToStatusTransfer_List() const { return get<E_RABs_SubjectToStatusTransfer_List>(3); }
53565                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
53566                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
53567                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
53568                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
53569                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
53570                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
53571                 bool is_unknown() const { return type == 7; }
53572                 void clear()
53573                 {
53574                         switch(type)
53575                         {
53576                         case 1: var.destroy<UE_X2AP_ID>(); break;
53577                         case 2: var.destroy<UE_X2AP_ID>(); break;
53578                         case 3: var.destroy<E_RABs_SubjectToStatusTransfer_List>(); break;
53579                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
53580                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
53581                         case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
53582                         }
53583                         type = 0; ref_nested().clear();
53584                 }
53585                 template<typename V> static inline void enumerate(V& v)
53586                 {
53587                         v.template operator()<UE_X2AP_ID>(1);
53588                         v.template operator()<UE_X2AP_ID>(2);
53589                         v.template operator()<E_RABs_SubjectToStatusTransfer_List>(3);
53590                         v.template operator()<UE_X2AP_ID_Extension>(4);
53591                         v.template operator()<UE_X2AP_ID_Extension>(5);
53592                         v.template operator()<SgNB_UE_X2AP_ID>(6);
53593
53594                 }
53595                 protected:
53596                 template<typename V> bool decode(size_t index, V& v)
53597                 {
53598                         clear();
53599                         switch(index)
53600                         {
53601                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
53602                         case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
53603                         case 3: v(select_id_E_RABs_SubjectToStatusTransfer_List()); return true;
53604                         case 4: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
53605                         case 5: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
53606                         case 6: v(select_id_SgNB_UE_X2AP_ID()); return true;
53607                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
53608                         }
53609                         return false;
53610
53611                 }
53612                 template<typename V> bool encode(size_t index, V& v) const
53613                 {
53614                         if(index != type) return false;
53615                         switch(type)
53616                         {
53617                         case 1: v(var.as<UE_X2AP_ID>()); return true;
53618                         case 2: v(var.as<UE_X2AP_ID>()); return true;
53619                         case 3: v(var.as<E_RABs_SubjectToStatusTransfer_List>()); return true;
53620                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
53621                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
53622                         case 6: v(var.as<SgNB_UE_X2AP_ID>()); return true;
53623                         }
53624                         return false;
53625
53626                 }
53627                 private:
53628                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
53629                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
53630                 union union_type
53631                 {
53632                         char dummy1[sizeof(E_RABs_SubjectToStatusTransfer_List)];
53633                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
53634                         char dummy3[sizeof(UE_X2AP_ID)];
53635                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
53636
53637                 };
53638                 asn::variant<sizeof(union_type)> var;
53639                 size_t type {0};
53640
53641         };
53642         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
53643         {
53644                 size_t get_index() const {return type;}
53645                 bool is_unknown() const { return type == 7; }
53646                 void clear() {type = 0;}
53647                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
53648                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
53649                 void select_id_E_RABs_SubjectToStatusTransfer_List() { set(mandatory); type=3;}
53650                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
53651                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
53652                 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
53653                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
53654                 template<typename V>  bool decode(V& v)
53655                 {
53656                         clear();
53657                         if(!v(ref_nested())) return false;
53658                         if(equal(mandatory)) { type = 1; return true; }
53659                         else if(equal(mandatory)) { type = 2; return true; }
53660                         else if(equal(mandatory)) { type = 3; return true; }
53661                         else if(equal(optional)) { type = 4; return true; }
53662                         else if(equal(optional)) { type = 5; return true; }
53663                         else if(equal(optional)) { type = 6; return true; }
53664                         else { type = 7; return true;}
53665                         return false;
53666
53667                 }
53668                 template<typename V> bool encode(V& v) const
53669                 {
53670                         return v(ref_nested());
53671
53672                 }
53673                 protected:
53674                 template<typename V>  bool decode(size_t index, V& v)
53675                 {
53676                         clear();
53677                         switch(index)
53678                         {
53679                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
53680                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
53681                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
53682                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
53683                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
53684                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
53685                         case 7: type = 7; return v(ref_nested());
53686                         ref_nested().clear();
53687                         }
53688                         return false;
53689
53690                 }
53691                 template<typename V> bool encode(size_t index, V& v) const
53692                 {
53693                         if(index != type) {return false;} return v(ref_nested());
53694
53695                 }
53696                 private:
53697                 size_t type {0};
53698
53699         };
53700
53701 };
53702 /*
53703 SNStatusTransfer ::= SEQUENCE {
53704         protocolIEs             ProtocolIE-Container    {{SNStatusTransfer-IEs}},
53705         ...
53706 }
53707 */
53708
53709 struct SNStatusTransfer : asn::sequence<1, 0, true, 0>
53710 {
53711         static constexpr const char* name() {return "SNStatusTransfer";}
53712         using parent_t = asn::sequence<1, 0, true, 0>;
53713         struct protocolIEs_t : ProtocolIE_Container<SNStatusTransfer_IEs>
53714         {
53715                 static constexpr const char* name() {return "protocolIEs_t";}
53716                 using parent_t = ProtocolIE_Container<SNStatusTransfer_IEs>;
53717
53718         };
53719         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
53720         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
53721         template<typename V> void decode(V& v)
53722         {
53723                 v(protocolIEs);
53724
53725         };
53726         template<typename V> void encode(V& v) const
53727         {
53728                 v(protocolIEs);
53729
53730         };
53731         void clear()
53732         {
53733                 protocolIEs.clear();
53734
53735         };
53736         private:
53737         protocolIEs_t   protocolIEs;
53738
53739 };
53740 /*
53741 SeNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
53742         { ID id-MeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
53743         { ID id-UE-SecurityCapabilities                 CRITICALITY reject      TYPE UESecurityCapabilities                             PRESENCE conditional}|
53744         -- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
53745         { ID id-SeNBSecurityKey                                 CRITICALITY reject      TYPE SeNBSecurityKey                                    PRESENCE conditional}|
53746         -- This IE shall be present if the Bearer Option IE is set to the value “SCG bearer” --
53747         { ID id-SeNBUEAggregateMaximumBitRate   CRITICALITY reject      TYPE UEAggregateMaximumBitRate                  PRESENCE mandatory}|
53748         { ID id-ServingPLMN                                             CRITICALITY ignore      TYPE PLMN-Identity                                              PRESENCE optional}|
53749         { ID id-E-RABs-ToBeAdded-List                   CRITICALITY reject      TYPE E-RABs-ToBeAdded-List                              PRESENCE mandatory}|
53750         { ID id-MeNBtoSeNBContainer                             CRITICALITY reject      TYPE MeNBtoSeNBContainer                                PRESENCE mandatory}|
53751         { ID id-CSGMembershipStatus                             CRITICALITY reject      TYPE CSGMembershipStatus                                PRESENCE optional}|
53752         { ID id-SeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE optional}|
53753         { ID id-SeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
53754         { ID id-ExpectedUEBehaviour                             CRITICALITY ignore      TYPE ExpectedUEBehaviour                                PRESENCE optional}|
53755         { ID id-MeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional},
53756         ...
53757 }
53758 */
53759
53760 struct SeNBAdditionRequest_IEs
53761 {
53762         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
53763         {
53764                 size_t get_index() const {return type;}
53765                 bool is_unknown() const { return type == 13; }
53766                 void clear() {type = 0;}
53767                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
53768                 void select_id_UE_SecurityCapabilities() { set(id_UE_SecurityCapabilities); type=2;}
53769                 void select_id_SeNBSecurityKey() { set(id_SeNBSecurityKey); type=3;}
53770                 void select_id_SeNBUEAggregateMaximumBitRate() { set(id_SeNBUEAggregateMaximumBitRate); type=4;}
53771                 void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
53772                 void select_id_E_RABs_ToBeAdded_List() { set(id_E_RABs_ToBeAdded_List); type=6;}
53773                 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
53774                 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
53775                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=9;}
53776                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
53777                 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=11;}
53778                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=12;}
53779                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
53780                 template<typename V>  bool decode(V& v)
53781                 {
53782                         clear();
53783                         if(!v(ref_nested())) return false;
53784                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
53785                         else if(equal(id_UE_SecurityCapabilities)) { type = 2; return true; }
53786                         else if(equal(id_SeNBSecurityKey)) { type = 3; return true; }
53787                         else if(equal(id_SeNBUEAggregateMaximumBitRate)) { type = 4; return true; }
53788                         else if(equal(id_ServingPLMN)) { type = 5; return true; }
53789                         else if(equal(id_E_RABs_ToBeAdded_List)) { type = 6; return true; }
53790                         else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
53791                         else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
53792                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 9; return true; }
53793                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
53794                         else if(equal(id_ExpectedUEBehaviour)) { type = 11; return true; }
53795                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 12; return true; }
53796                         else { type = 13; return true;}
53797                         return false;
53798
53799                 }
53800                 template<typename V> bool encode(V& v) const
53801                 {
53802                         return v(ref_nested());
53803
53804                 }
53805                 protected:
53806                 template<typename V>  bool decode(size_t index, V& v)
53807                 {
53808                         clear();
53809                         switch(index)
53810                         {
53811                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
53812                         case 2: type = 2; if(v(ref_nested())) { return equal(id_UE_SecurityCapabilities);} return false;
53813                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SeNBSecurityKey);} return false;
53814                         case 4: type = 4; if(v(ref_nested())) { return equal(id_SeNBUEAggregateMaximumBitRate);} return false;
53815                         case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
53816                         case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_List);} return false;
53817                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
53818                         case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
53819                         case 9: type = 9; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
53820                         case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
53821                         case 11: type = 11; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
53822                         case 12: type = 12; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
53823                         case 13: type = 13; return v(ref_nested());
53824                         ref_nested().clear();
53825                         }
53826                         return false;
53827
53828                 }
53829                 template<typename V> bool encode(size_t index, V& v) const
53830                 {
53831                         if(index != type) {return false;} return v(ref_nested());
53832
53833                 }
53834                 private:
53835                 size_t type {0};
53836
53837         };
53838         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
53839         {
53840                 size_t get_index() const {return type;}
53841                 bool is_unknown() const { return type == 13; }
53842                 void clear() {type = 0;}
53843                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
53844                 void select_id_UE_SecurityCapabilities() { set(reject); type=2;}
53845                 void select_id_SeNBSecurityKey() { set(reject); type=3;}
53846                 void select_id_SeNBUEAggregateMaximumBitRate() { set(reject); type=4;}
53847                 void select_id_ServingPLMN() { set(ignore); type=5;}
53848                 void select_id_E_RABs_ToBeAdded_List() { set(reject); type=6;}
53849                 void select_id_MeNBtoSeNBContainer() { set(reject); type=7;}
53850                 void select_id_CSGMembershipStatus() { set(reject); type=8;}
53851                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=9;}
53852                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
53853                 void select_id_ExpectedUEBehaviour() { set(ignore); type=11;}
53854                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=12;}
53855                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
53856                 template<typename V>  bool decode(V& v)
53857                 {
53858                         clear();
53859                         if(!v(ref_nested())) return false;
53860                         if(equal(reject)) { type = 1; return true; }
53861                         else if(equal(reject)) { type = 2; return true; }
53862                         else if(equal(reject)) { type = 3; return true; }
53863                         else if(equal(reject)) { type = 4; return true; }
53864                         else if(equal(ignore)) { type = 5; return true; }
53865                         else if(equal(reject)) { type = 6; return true; }
53866                         else if(equal(reject)) { type = 7; return true; }
53867                         else if(equal(reject)) { type = 8; return true; }
53868                         else if(equal(reject)) { type = 9; return true; }
53869                         else if(equal(reject)) { type = 10; return true; }
53870                         else if(equal(ignore)) { type = 11; return true; }
53871                         else if(equal(reject)) { type = 12; return true; }
53872                         else { type = 13; return true;}
53873                         return false;
53874
53875                 }
53876                 template<typename V> bool encode(V& v) const
53877                 {
53878                         return v(ref_nested());
53879
53880                 }
53881                 protected:
53882                 template<typename V>  bool decode(size_t index, V& v)
53883                 {
53884                         clear();
53885                         switch(index)
53886                         {
53887                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
53888                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
53889                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
53890                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
53891                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
53892                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
53893                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
53894                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
53895                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
53896                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
53897                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
53898                         case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
53899                         case 13: type = 13; return v(ref_nested());
53900                         ref_nested().clear();
53901                         }
53902                         return false;
53903
53904                 }
53905                 template<typename V> bool encode(size_t index, V& v) const
53906                 {
53907                         if(index != type) {return false;} return v(ref_nested());
53908
53909                 }
53910                 private:
53911                 size_t type {0};
53912
53913         };
53914         struct Value_t : asn::typefield<true>
53915         {
53916                 ~Value_t()      {clear();}
53917                 size_t get_index() const {return type;}
53918                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
53919                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
53920                 UESecurityCapabilities& select_id_UE_SecurityCapabilities() { return set<UESecurityCapabilities>(2); }
53921                 UESecurityCapabilities const* get_id_UE_SecurityCapabilities() const { return get<UESecurityCapabilities>(2); }
53922                 SeNBSecurityKey& select_id_SeNBSecurityKey() { return set<SeNBSecurityKey>(3); }
53923                 SeNBSecurityKey const* get_id_SeNBSecurityKey() const { return get<SeNBSecurityKey>(3); }
53924                 UEAggregateMaximumBitRate& select_id_SeNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
53925                 UEAggregateMaximumBitRate const* get_id_SeNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
53926                 PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
53927                 PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
53928                 E_RABs_ToBeAdded_List& select_id_E_RABs_ToBeAdded_List() { return set<E_RABs_ToBeAdded_List>(6); }
53929                 E_RABs_ToBeAdded_List const* get_id_E_RABs_ToBeAdded_List() const { return get<E_RABs_ToBeAdded_List>(6); }
53930                 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
53931                 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
53932                 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
53933                 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
53934                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(9); }
53935                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(9); }
53936                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
53937                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
53938                 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(11); }
53939                 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(11); }
53940                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(12); }
53941                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(12); }
53942                 bool is_unknown() const { return type == 13; }
53943                 void clear()
53944                 {
53945                         switch(type)
53946                         {
53947                         case 1: var.destroy<UE_X2AP_ID>(); break;
53948                         case 2: var.destroy<UESecurityCapabilities>(); break;
53949                         case 3: var.destroy<SeNBSecurityKey>(); break;
53950                         case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
53951                         case 5: var.destroy<PLMN_Identity>(); break;
53952                         case 6: var.destroy<E_RABs_ToBeAdded_List>(); break;
53953                         case 7: var.destroy<MeNBtoSeNBContainer>(); break;
53954                         case 8: var.destroy<CSGMembershipStatus>(); break;
53955                         case 9: var.destroy<UE_X2AP_ID>(); break;
53956                         case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
53957                         case 11: var.destroy<ExpectedUEBehaviour>(); break;
53958                         case 12: var.destroy<UE_X2AP_ID_Extension>(); break;
53959                         }
53960                         type = 0; ref_nested().clear();
53961                 }
53962                 template<typename V> static inline void enumerate(V& v)
53963                 {
53964                         v.template operator()<UE_X2AP_ID>(1);
53965                         v.template operator()<UESecurityCapabilities>(2);
53966                         v.template operator()<SeNBSecurityKey>(3);
53967                         v.template operator()<UEAggregateMaximumBitRate>(4);
53968                         v.template operator()<PLMN_Identity>(5);
53969                         v.template operator()<E_RABs_ToBeAdded_List>(6);
53970                         v.template operator()<MeNBtoSeNBContainer>(7);
53971                         v.template operator()<CSGMembershipStatus>(8);
53972                         v.template operator()<UE_X2AP_ID>(9);
53973                         v.template operator()<UE_X2AP_ID_Extension>(10);
53974                         v.template operator()<ExpectedUEBehaviour>(11);
53975                         v.template operator()<UE_X2AP_ID_Extension>(12);
53976
53977                 }
53978                 protected:
53979                 template<typename V> bool decode(size_t index, V& v)
53980                 {
53981                         clear();
53982                         switch(index)
53983                         {
53984                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
53985                         case 2: v(select_id_UE_SecurityCapabilities()); return true;
53986                         case 3: v(select_id_SeNBSecurityKey()); return true;
53987                         case 4: v(select_id_SeNBUEAggregateMaximumBitRate()); return true;
53988                         case 5: v(select_id_ServingPLMN()); return true;
53989                         case 6: v(select_id_E_RABs_ToBeAdded_List()); return true;
53990                         case 7: v(select_id_MeNBtoSeNBContainer()); return true;
53991                         case 8: v(select_id_CSGMembershipStatus()); return true;
53992                         case 9: v(select_id_SeNB_UE_X2AP_ID()); return true;
53993                         case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
53994                         case 11: v(select_id_ExpectedUEBehaviour()); return true;
53995                         case 12: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
53996                         case 13: if(type != 13) {clear(); asn::base::set();} type = 13; return true;
53997                         }
53998                         return false;
53999
54000                 }
54001                 template<typename V> bool encode(size_t index, V& v) const
54002                 {
54003                         if(index != type) return false;
54004                         switch(type)
54005                         {
54006                         case 1: v(var.as<UE_X2AP_ID>()); return true;
54007                         case 2: v(var.as<UESecurityCapabilities>()); return true;
54008                         case 3: v(var.as<SeNBSecurityKey>()); return true;
54009                         case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
54010                         case 5: v(var.as<PLMN_Identity>()); return true;
54011                         case 6: v(var.as<E_RABs_ToBeAdded_List>()); return true;
54012                         case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
54013                         case 8: v(var.as<CSGMembershipStatus>()); return true;
54014                         case 9: v(var.as<UE_X2AP_ID>()); return true;
54015                         case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
54016                         case 11: v(var.as<ExpectedUEBehaviour>()); return true;
54017                         case 12: v(var.as<UE_X2AP_ID_Extension>()); return true;
54018                         }
54019                         return false;
54020
54021                 }
54022                 private:
54023                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54024                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54025                 union union_type
54026                 {
54027                         char dummy1[sizeof(CSGMembershipStatus)];
54028                         char dummy2[sizeof(E_RABs_ToBeAdded_List)];
54029                         char dummy3[sizeof(ExpectedUEBehaviour)];
54030                         char dummy4[sizeof(MeNBtoSeNBContainer)];
54031                         char dummy5[sizeof(PLMN_Identity)];
54032                         char dummy6[sizeof(SeNBSecurityKey)];
54033                         char dummy7[sizeof(UEAggregateMaximumBitRate)];
54034                         char dummy8[sizeof(UESecurityCapabilities)];
54035                         char dummy9[sizeof(UE_X2AP_ID)];
54036                         char dummy10[sizeof(UE_X2AP_ID_Extension)];
54037
54038                 };
54039                 asn::variant<sizeof(union_type)> var;
54040                 size_t type {0};
54041
54042         };
54043         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54044         {
54045                 size_t get_index() const {return type;}
54046                 bool is_unknown() const { return type == 13; }
54047                 void clear() {type = 0;}
54048                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54049                 void select_id_UE_SecurityCapabilities() { set(conditional); type=2;}
54050                 void select_id_SeNBSecurityKey() { set(conditional); type=3;}
54051                 void select_id_SeNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
54052                 void select_id_ServingPLMN() { set(optional); type=5;}
54053                 void select_id_E_RABs_ToBeAdded_List() { set(mandatory); type=6;}
54054                 void select_id_MeNBtoSeNBContainer() { set(mandatory); type=7;}
54055                 void select_id_CSGMembershipStatus() { set(optional); type=8;}
54056                 void select_id_SeNB_UE_X2AP_ID() { set(optional); type=9;}
54057                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
54058                 void select_id_ExpectedUEBehaviour() { set(optional); type=11;}
54059                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=12;}
54060                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54061                 template<typename V>  bool decode(V& v)
54062                 {
54063                         clear();
54064                         if(!v(ref_nested())) return false;
54065                         if(equal(mandatory)) { type = 1; return true; }
54066                         else if(equal(conditional)) { type = 2; return true; }
54067                         else if(equal(conditional)) { type = 3; return true; }
54068                         else if(equal(mandatory)) { type = 4; return true; }
54069                         else if(equal(optional)) { type = 5; return true; }
54070                         else if(equal(mandatory)) { type = 6; return true; }
54071                         else if(equal(mandatory)) { type = 7; return true; }
54072                         else if(equal(optional)) { type = 8; return true; }
54073                         else if(equal(optional)) { type = 9; return true; }
54074                         else if(equal(optional)) { type = 10; return true; }
54075                         else if(equal(optional)) { type = 11; return true; }
54076                         else if(equal(optional)) { type = 12; return true; }
54077                         else { type = 13; return true;}
54078                         return false;
54079
54080                 }
54081                 template<typename V> bool encode(V& v) const
54082                 {
54083                         return v(ref_nested());
54084
54085                 }
54086                 protected:
54087                 template<typename V>  bool decode(size_t index, V& v)
54088                 {
54089                         clear();
54090                         switch(index)
54091                         {
54092                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54093                         case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
54094                         case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
54095                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
54096                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
54097                         case 6: type = 6; if(v(ref_nested())) { return equal(mandatory);} return false;
54098                         case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} return false;
54099                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
54100                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
54101                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
54102                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
54103                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
54104                         case 13: type = 13; return v(ref_nested());
54105                         ref_nested().clear();
54106                         }
54107                         return false;
54108
54109                 }
54110                 template<typename V> bool encode(size_t index, V& v) const
54111                 {
54112                         if(index != type) {return false;} return v(ref_nested());
54113
54114                 }
54115                 private:
54116                 size_t type {0};
54117
54118         };
54119
54120 };
54121 /*
54122 SeNBAdditionRequest ::= SEQUENCE {
54123         protocolIEs             ProtocolIE-Container    {{SeNBAdditionRequest-IEs}},
54124         ...
54125 }
54126 */
54127
54128 struct SeNBAdditionRequest : asn::sequence<1, 0, true, 0>
54129 {
54130         static constexpr const char* name() {return "SeNBAdditionRequest";}
54131         using parent_t = asn::sequence<1, 0, true, 0>;
54132         struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequest_IEs>
54133         {
54134                 static constexpr const char* name() {return "protocolIEs_t";}
54135                 using parent_t = ProtocolIE_Container<SeNBAdditionRequest_IEs>;
54136
54137         };
54138         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54139         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54140         template<typename V> void decode(V& v)
54141         {
54142                 v(protocolIEs);
54143
54144         };
54145         template<typename V> void encode(V& v) const
54146         {
54147                 v(protocolIEs);
54148
54149         };
54150         void clear()
54151         {
54152                 protocolIEs.clear();
54153
54154         };
54155         private:
54156         protocolIEs_t   protocolIEs;
54157
54158 };
54159 /*
54160 SeNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
54161         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
54162         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
54163         { ID id-E-RABs-Admitted-ToBeAdded-List          CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-List     PRESENCE mandatory}|
54164         { ID id-E-RABs-NotAdmitted-List                         CRITICALITY ignore      TYPE E-RAB-List                                                 PRESENCE optional}|
54165         { ID id-SeNBtoMeNBContainer                                     CRITICALITY reject      TYPE SeNBtoMeNBContainer                                PRESENCE mandatory}|
54166         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics                             PRESENCE optional}|
54167         { ID id-GW-TransportLayerAddress                        CRITICALITY ignore      TYPE TransportLayerAddress                              PRESENCE optional}|
54168         { ID id-SIPTO-L-GW-TransportLayerAddress        CRITICALITY ignore      TYPE TransportLayerAddress                              PRESENCE optional}|
54169         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
54170         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
54171         { ID id-Tunnel-Information-for-BBF                      CRITICALITY ignore      TYPE TunnelInformation                                  PRESENCE optional},
54172         ...
54173 }
54174 */
54175
54176 struct SeNBAdditionRequestAcknowledge_IEs
54177 {
54178         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54179         {
54180                 size_t get_index() const {return type;}
54181                 bool is_unknown() const { return type == 12; }
54182                 void clear() {type = 0;}
54183                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54184                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54185                 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(id_E_RABs_Admitted_ToBeAdded_List); type=3;}
54186                 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
54187                 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=5;}
54188                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
54189                 void select_id_GW_TransportLayerAddress() { set(id_GW_TransportLayerAddress); type=7;}
54190                 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(id_SIPTO_L_GW_TransportLayerAddress); type=8;}
54191                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
54192                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
54193                 void select_id_Tunnel_Information_for_BBF() { set(id_Tunnel_Information_for_BBF); type=11;}
54194                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54195                 template<typename V>  bool decode(V& v)
54196                 {
54197                         clear();
54198                         if(!v(ref_nested())) return false;
54199                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54200                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54201                         else if(equal(id_E_RABs_Admitted_ToBeAdded_List)) { type = 3; return true; }
54202                         else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
54203                         else if(equal(id_SeNBtoMeNBContainer)) { type = 5; return true; }
54204                         else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
54205                         else if(equal(id_GW_TransportLayerAddress)) { type = 7; return true; }
54206                         else if(equal(id_SIPTO_L_GW_TransportLayerAddress)) { type = 8; return true; }
54207                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
54208                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
54209                         else if(equal(id_Tunnel_Information_for_BBF)) { type = 11; return true; }
54210                         else { type = 12; return true;}
54211                         return false;
54212
54213                 }
54214                 template<typename V> bool encode(V& v) const
54215                 {
54216                         return v(ref_nested());
54217
54218                 }
54219                 protected:
54220                 template<typename V>  bool decode(size_t index, V& v)
54221                 {
54222                         clear();
54223                         switch(index)
54224                         {
54225                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54226                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54227                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_List);} return false;
54228                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
54229                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
54230                         case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
54231                         case 7: type = 7; if(v(ref_nested())) { return equal(id_GW_TransportLayerAddress);} return false;
54232                         case 8: type = 8; if(v(ref_nested())) { return equal(id_SIPTO_L_GW_TransportLayerAddress);} return false;
54233                         case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54234                         case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54235                         case 11: type = 11; if(v(ref_nested())) { return equal(id_Tunnel_Information_for_BBF);} return false;
54236                         case 12: type = 12; return v(ref_nested());
54237                         ref_nested().clear();
54238                         }
54239                         return false;
54240
54241                 }
54242                 template<typename V> bool encode(size_t index, V& v) const
54243                 {
54244                         if(index != type) {return false;} return v(ref_nested());
54245
54246                 }
54247                 private:
54248                 size_t type {0};
54249
54250         };
54251         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54252         {
54253                 size_t get_index() const {return type;}
54254                 bool is_unknown() const { return type == 12; }
54255                 void clear() {type = 0;}
54256                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54257                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54258                 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(ignore); type=3;}
54259                 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
54260                 void select_id_SeNBtoMeNBContainer() { set(reject); type=5;}
54261                 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
54262                 void select_id_GW_TransportLayerAddress() { set(ignore); type=7;}
54263                 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(ignore); type=8;}
54264                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
54265                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
54266                 void select_id_Tunnel_Information_for_BBF() { set(ignore); type=11;}
54267                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54268                 template<typename V>  bool decode(V& v)
54269                 {
54270                         clear();
54271                         if(!v(ref_nested())) return false;
54272                         if(equal(reject)) { type = 1; return true; }
54273                         else if(equal(reject)) { type = 2; return true; }
54274                         else if(equal(ignore)) { type = 3; return true; }
54275                         else if(equal(ignore)) { type = 4; return true; }
54276                         else if(equal(reject)) { type = 5; return true; }
54277                         else if(equal(ignore)) { type = 6; return true; }
54278                         else if(equal(ignore)) { type = 7; return true; }
54279                         else if(equal(ignore)) { type = 8; return true; }
54280                         else if(equal(reject)) { type = 9; return true; }
54281                         else if(equal(reject)) { type = 10; return true; }
54282                         else if(equal(ignore)) { type = 11; return true; }
54283                         else { type = 12; return true;}
54284                         return false;
54285
54286                 }
54287                 template<typename V> bool encode(V& v) const
54288                 {
54289                         return v(ref_nested());
54290
54291                 }
54292                 protected:
54293                 template<typename V>  bool decode(size_t index, V& v)
54294                 {
54295                         clear();
54296                         switch(index)
54297                         {
54298                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54299                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54300                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54301                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54302                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
54303                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
54304                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
54305                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
54306                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
54307                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
54308                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
54309                         case 12: type = 12; return v(ref_nested());
54310                         ref_nested().clear();
54311                         }
54312                         return false;
54313
54314                 }
54315                 template<typename V> bool encode(size_t index, V& v) const
54316                 {
54317                         if(index != type) {return false;} return v(ref_nested());
54318
54319                 }
54320                 private:
54321                 size_t type {0};
54322
54323         };
54324         struct Value_t : asn::typefield<true>
54325         {
54326                 ~Value_t()      {clear();}
54327                 size_t get_index() const {return type;}
54328                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
54329                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
54330                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
54331                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
54332                 E_RABs_Admitted_ToBeAdded_List& select_id_E_RABs_Admitted_ToBeAdded_List() { return set<E_RABs_Admitted_ToBeAdded_List>(3); }
54333                 E_RABs_Admitted_ToBeAdded_List const* get_id_E_RABs_Admitted_ToBeAdded_List() const { return get<E_RABs_Admitted_ToBeAdded_List>(3); }
54334                 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
54335                 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
54336                 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(5); }
54337                 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(5); }
54338                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
54339                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
54340                 TransportLayerAddress& select_id_GW_TransportLayerAddress() { return set<TransportLayerAddress>(7); }
54341                 TransportLayerAddress const* get_id_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(7); }
54342                 TransportLayerAddress& select_id_SIPTO_L_GW_TransportLayerAddress() { return set<TransportLayerAddress>(8); }
54343                 TransportLayerAddress const* get_id_SIPTO_L_GW_TransportLayerAddress() const { return get<TransportLayerAddress>(8); }
54344                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
54345                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
54346                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
54347                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
54348                 TunnelInformation& select_id_Tunnel_Information_for_BBF() { return set<TunnelInformation>(11); }
54349                 TunnelInformation const* get_id_Tunnel_Information_for_BBF() const { return get<TunnelInformation>(11); }
54350                 bool is_unknown() const { return type == 12; }
54351                 void clear()
54352                 {
54353                         switch(type)
54354                         {
54355                         case 1: var.destroy<UE_X2AP_ID>(); break;
54356                         case 2: var.destroy<UE_X2AP_ID>(); break;
54357                         case 3: var.destroy<E_RABs_Admitted_ToBeAdded_List>(); break;
54358                         case 4: var.destroy<E_RAB_List>(); break;
54359                         case 5: var.destroy<SeNBtoMeNBContainer>(); break;
54360                         case 6: var.destroy<CriticalityDiagnostics>(); break;
54361                         case 7: var.destroy<TransportLayerAddress>(); break;
54362                         case 8: var.destroy<TransportLayerAddress>(); break;
54363                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
54364                         case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
54365                         case 11: var.destroy<TunnelInformation>(); break;
54366                         }
54367                         type = 0; ref_nested().clear();
54368                 }
54369                 template<typename V> static inline void enumerate(V& v)
54370                 {
54371                         v.template operator()<UE_X2AP_ID>(1);
54372                         v.template operator()<UE_X2AP_ID>(2);
54373                         v.template operator()<E_RABs_Admitted_ToBeAdded_List>(3);
54374                         v.template operator()<E_RAB_List>(4);
54375                         v.template operator()<SeNBtoMeNBContainer>(5);
54376                         v.template operator()<CriticalityDiagnostics>(6);
54377                         v.template operator()<TransportLayerAddress>(7);
54378                         v.template operator()<TransportLayerAddress>(8);
54379                         v.template operator()<UE_X2AP_ID_Extension>(9);
54380                         v.template operator()<UE_X2AP_ID_Extension>(10);
54381                         v.template operator()<TunnelInformation>(11);
54382
54383                 }
54384                 protected:
54385                 template<typename V> bool decode(size_t index, V& v)
54386                 {
54387                         clear();
54388                         switch(index)
54389                         {
54390                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
54391                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
54392                         case 3: v(select_id_E_RABs_Admitted_ToBeAdded_List()); return true;
54393                         case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
54394                         case 5: v(select_id_SeNBtoMeNBContainer()); return true;
54395                         case 6: v(select_id_CriticalityDiagnostics()); return true;
54396                         case 7: v(select_id_GW_TransportLayerAddress()); return true;
54397                         case 8: v(select_id_SIPTO_L_GW_TransportLayerAddress()); return true;
54398                         case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
54399                         case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
54400                         case 11: v(select_id_Tunnel_Information_for_BBF()); return true;
54401                         case 12: if(type != 12) {clear(); asn::base::set();} type = 12; return true;
54402                         }
54403                         return false;
54404
54405                 }
54406                 template<typename V> bool encode(size_t index, V& v) const
54407                 {
54408                         if(index != type) return false;
54409                         switch(type)
54410                         {
54411                         case 1: v(var.as<UE_X2AP_ID>()); return true;
54412                         case 2: v(var.as<UE_X2AP_ID>()); return true;
54413                         case 3: v(var.as<E_RABs_Admitted_ToBeAdded_List>()); return true;
54414                         case 4: v(var.as<E_RAB_List>()); return true;
54415                         case 5: v(var.as<SeNBtoMeNBContainer>()); return true;
54416                         case 6: v(var.as<CriticalityDiagnostics>()); return true;
54417                         case 7: v(var.as<TransportLayerAddress>()); return true;
54418                         case 8: v(var.as<TransportLayerAddress>()); return true;
54419                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
54420                         case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
54421                         case 11: v(var.as<TunnelInformation>()); return true;
54422                         }
54423                         return false;
54424
54425                 }
54426                 private:
54427                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54428                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54429                 union union_type
54430                 {
54431                         char dummy1[sizeof(CriticalityDiagnostics)];
54432                         char dummy2[sizeof(E_RAB_List)];
54433                         char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_List)];
54434                         char dummy4[sizeof(SeNBtoMeNBContainer)];
54435                         char dummy5[sizeof(TransportLayerAddress)];
54436                         char dummy6[sizeof(TunnelInformation)];
54437                         char dummy7[sizeof(UE_X2AP_ID)];
54438                         char dummy8[sizeof(UE_X2AP_ID_Extension)];
54439
54440                 };
54441                 asn::variant<sizeof(union_type)> var;
54442                 size_t type {0};
54443
54444         };
54445         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54446         {
54447                 size_t get_index() const {return type;}
54448                 bool is_unknown() const { return type == 12; }
54449                 void clear() {type = 0;}
54450                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54451                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
54452                 void select_id_E_RABs_Admitted_ToBeAdded_List() { set(mandatory); type=3;}
54453                 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
54454                 void select_id_SeNBtoMeNBContainer() { set(mandatory); type=5;}
54455                 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
54456                 void select_id_GW_TransportLayerAddress() { set(optional); type=7;}
54457                 void select_id_SIPTO_L_GW_TransportLayerAddress() { set(optional); type=8;}
54458                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
54459                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
54460                 void select_id_Tunnel_Information_for_BBF() { set(optional); type=11;}
54461                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54462                 template<typename V>  bool decode(V& v)
54463                 {
54464                         clear();
54465                         if(!v(ref_nested())) return false;
54466                         if(equal(mandatory)) { type = 1; return true; }
54467                         else if(equal(mandatory)) { type = 2; return true; }
54468                         else if(equal(mandatory)) { type = 3; return true; }
54469                         else if(equal(optional)) { type = 4; return true; }
54470                         else if(equal(mandatory)) { type = 5; return true; }
54471                         else if(equal(optional)) { type = 6; return true; }
54472                         else if(equal(optional)) { type = 7; return true; }
54473                         else if(equal(optional)) { type = 8; return true; }
54474                         else if(equal(optional)) { type = 9; return true; }
54475                         else if(equal(optional)) { type = 10; return true; }
54476                         else if(equal(optional)) { type = 11; return true; }
54477                         else { type = 12; return true;}
54478                         return false;
54479
54480                 }
54481                 template<typename V> bool encode(V& v) const
54482                 {
54483                         return v(ref_nested());
54484
54485                 }
54486                 protected:
54487                 template<typename V>  bool decode(size_t index, V& v)
54488                 {
54489                         clear();
54490                         switch(index)
54491                         {
54492                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54493                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
54494                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
54495                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
54496                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
54497                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
54498                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
54499                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
54500                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
54501                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
54502                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
54503                         case 12: type = 12; return v(ref_nested());
54504                         ref_nested().clear();
54505                         }
54506                         return false;
54507
54508                 }
54509                 template<typename V> bool encode(size_t index, V& v) const
54510                 {
54511                         if(index != type) {return false;} return v(ref_nested());
54512
54513                 }
54514                 private:
54515                 size_t type {0};
54516
54517         };
54518
54519 };
54520 /*
54521 SeNBAdditionRequestAcknowledge ::= SEQUENCE {
54522         protocolIEs             ProtocolIE-Container    {{SeNBAdditionRequestAcknowledge-IEs}},
54523         ...
54524 }
54525 */
54526
54527 struct SeNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
54528 {
54529         static constexpr const char* name() {return "SeNBAdditionRequestAcknowledge";}
54530         using parent_t = asn::sequence<1, 0, true, 0>;
54531         struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>
54532         {
54533                 static constexpr const char* name() {return "protocolIEs_t";}
54534                 using parent_t = ProtocolIE_Container<SeNBAdditionRequestAcknowledge_IEs>;
54535
54536         };
54537         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54538         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54539         template<typename V> void decode(V& v)
54540         {
54541                 v(protocolIEs);
54542
54543         };
54544         template<typename V> void encode(V& v) const
54545         {
54546                 v(protocolIEs);
54547
54548         };
54549         void clear()
54550         {
54551                 protocolIEs.clear();
54552
54553         };
54554         private:
54555         protocolIEs_t   protocolIEs;
54556
54557 };
54558 /*
54559 SeNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
54560         { ID id-MeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
54561         { ID id-SeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
54562         { ID id-Cause                                                   CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
54563         { ID id-CriticalityDiagnostics                  CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
54564         { ID id-MeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
54565         { ID id-SeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
54566         ...
54567 }
54568 */
54569
54570 struct SeNBAdditionRequestReject_IEs
54571 {
54572         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54573         {
54574                 size_t get_index() const {return type;}
54575                 bool is_unknown() const { return type == 7; }
54576                 void clear() {type = 0;}
54577                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54578                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54579                 void select_id_Cause() { set(id_Cause); type=3;}
54580                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
54581                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
54582                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
54583                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54584                 template<typename V>  bool decode(V& v)
54585                 {
54586                         clear();
54587                         if(!v(ref_nested())) return false;
54588                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54589                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54590                         else if(equal(id_Cause)) { type = 3; return true; }
54591                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
54592                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
54593                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
54594                         else { type = 7; return true;}
54595                         return false;
54596
54597                 }
54598                 template<typename V> bool encode(V& v) const
54599                 {
54600                         return v(ref_nested());
54601
54602                 }
54603                 protected:
54604                 template<typename V>  bool decode(size_t index, V& v)
54605                 {
54606                         clear();
54607                         switch(index)
54608                         {
54609                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54610                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54611                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
54612                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
54613                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54614                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54615                         case 7: type = 7; return v(ref_nested());
54616                         ref_nested().clear();
54617                         }
54618                         return false;
54619
54620                 }
54621                 template<typename V> bool encode(size_t index, V& v) const
54622                 {
54623                         if(index != type) {return false;} return v(ref_nested());
54624
54625                 }
54626                 private:
54627                 size_t type {0};
54628
54629         };
54630         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54631         {
54632                 size_t get_index() const {return type;}
54633                 bool is_unknown() const { return type == 7; }
54634                 void clear() {type = 0;}
54635                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54636                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54637                 void select_id_Cause() { set(ignore); type=3;}
54638                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
54639                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
54640                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
54641                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54642                 template<typename V>  bool decode(V& v)
54643                 {
54644                         clear();
54645                         if(!v(ref_nested())) return false;
54646                         if(equal(reject)) { type = 1; return true; }
54647                         else if(equal(reject)) { type = 2; return true; }
54648                         else if(equal(ignore)) { type = 3; return true; }
54649                         else if(equal(ignore)) { type = 4; return true; }
54650                         else if(equal(reject)) { type = 5; return true; }
54651                         else if(equal(reject)) { type = 6; return true; }
54652                         else { type = 7; return true;}
54653                         return false;
54654
54655                 }
54656                 template<typename V> bool encode(V& v) const
54657                 {
54658                         return v(ref_nested());
54659
54660                 }
54661                 protected:
54662                 template<typename V>  bool decode(size_t index, V& v)
54663                 {
54664                         clear();
54665                         switch(index)
54666                         {
54667                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54668                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54669                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54670                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54671                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
54672                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
54673                         case 7: type = 7; return v(ref_nested());
54674                         ref_nested().clear();
54675                         }
54676                         return false;
54677
54678                 }
54679                 template<typename V> bool encode(size_t index, V& v) const
54680                 {
54681                         if(index != type) {return false;} return v(ref_nested());
54682
54683                 }
54684                 private:
54685                 size_t type {0};
54686
54687         };
54688         struct Value_t : asn::typefield<true>
54689         {
54690                 ~Value_t()      {clear();}
54691                 size_t get_index() const {return type;}
54692                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
54693                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
54694                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
54695                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
54696                 Cause& select_id_Cause() { return set<Cause>(3); }
54697                 Cause const* get_id_Cause() const { return get<Cause>(3); }
54698                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
54699                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
54700                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
54701                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
54702                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
54703                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
54704                 bool is_unknown() const { return type == 7; }
54705                 void clear()
54706                 {
54707                         switch(type)
54708                         {
54709                         case 1: var.destroy<UE_X2AP_ID>(); break;
54710                         case 2: var.destroy<UE_X2AP_ID>(); break;
54711                         case 3: var.destroy<Cause>(); break;
54712                         case 4: var.destroy<CriticalityDiagnostics>(); break;
54713                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
54714                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
54715                         }
54716                         type = 0; ref_nested().clear();
54717                 }
54718                 template<typename V> static inline void enumerate(V& v)
54719                 {
54720                         v.template operator()<UE_X2AP_ID>(1);
54721                         v.template operator()<UE_X2AP_ID>(2);
54722                         v.template operator()<Cause>(3);
54723                         v.template operator()<CriticalityDiagnostics>(4);
54724                         v.template operator()<UE_X2AP_ID_Extension>(5);
54725                         v.template operator()<UE_X2AP_ID_Extension>(6);
54726
54727                 }
54728                 protected:
54729                 template<typename V> bool decode(size_t index, V& v)
54730                 {
54731                         clear();
54732                         switch(index)
54733                         {
54734                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
54735                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
54736                         case 3: v(select_id_Cause()); return true;
54737                         case 4: v(select_id_CriticalityDiagnostics()); return true;
54738                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
54739                         case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
54740                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
54741                         }
54742                         return false;
54743
54744                 }
54745                 template<typename V> bool encode(size_t index, V& v) const
54746                 {
54747                         if(index != type) return false;
54748                         switch(type)
54749                         {
54750                         case 1: v(var.as<UE_X2AP_ID>()); return true;
54751                         case 2: v(var.as<UE_X2AP_ID>()); return true;
54752                         case 3: v(var.as<Cause>()); return true;
54753                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
54754                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
54755                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
54756                         }
54757                         return false;
54758
54759                 }
54760                 private:
54761                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
54762                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
54763                 union union_type
54764                 {
54765                         char dummy1[sizeof(Cause)];
54766                         char dummy2[sizeof(CriticalityDiagnostics)];
54767                         char dummy3[sizeof(UE_X2AP_ID)];
54768                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
54769
54770                 };
54771                 asn::variant<sizeof(union_type)> var;
54772                 size_t type {0};
54773
54774         };
54775         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
54776         {
54777                 size_t get_index() const {return type;}
54778                 bool is_unknown() const { return type == 7; }
54779                 void clear() {type = 0;}
54780                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
54781                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
54782                 void select_id_Cause() { set(mandatory); type=3;}
54783                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
54784                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
54785                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
54786                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
54787                 template<typename V>  bool decode(V& v)
54788                 {
54789                         clear();
54790                         if(!v(ref_nested())) return false;
54791                         if(equal(mandatory)) { type = 1; return true; }
54792                         else if(equal(mandatory)) { type = 2; return true; }
54793                         else if(equal(mandatory)) { type = 3; return true; }
54794                         else if(equal(optional)) { type = 4; return true; }
54795                         else if(equal(optional)) { type = 5; return true; }
54796                         else if(equal(optional)) { type = 6; return true; }
54797                         else { type = 7; return true;}
54798                         return false;
54799
54800                 }
54801                 template<typename V> bool encode(V& v) const
54802                 {
54803                         return v(ref_nested());
54804
54805                 }
54806                 protected:
54807                 template<typename V>  bool decode(size_t index, V& v)
54808                 {
54809                         clear();
54810                         switch(index)
54811                         {
54812                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
54813                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
54814                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
54815                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
54816                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
54817                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
54818                         case 7: type = 7; return v(ref_nested());
54819                         ref_nested().clear();
54820                         }
54821                         return false;
54822
54823                 }
54824                 template<typename V> bool encode(size_t index, V& v) const
54825                 {
54826                         if(index != type) {return false;} return v(ref_nested());
54827
54828                 }
54829                 private:
54830                 size_t type {0};
54831
54832         };
54833
54834 };
54835 /*
54836 SeNBAdditionRequestReject ::= SEQUENCE {
54837         protocolIEs             ProtocolIE-Container    {{SeNBAdditionRequestReject-IEs}},
54838         ...
54839 }
54840 */
54841
54842 struct SeNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
54843 {
54844         static constexpr const char* name() {return "SeNBAdditionRequestReject";}
54845         using parent_t = asn::sequence<1, 0, true, 0>;
54846         struct protocolIEs_t : ProtocolIE_Container<SeNBAdditionRequestReject_IEs>
54847         {
54848                 static constexpr const char* name() {return "protocolIEs_t";}
54849                 using parent_t = ProtocolIE_Container<SeNBAdditionRequestReject_IEs>;
54850
54851         };
54852         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
54853         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
54854         template<typename V> void decode(V& v)
54855         {
54856                 v(protocolIEs);
54857
54858         };
54859         template<typename V> void encode(V& v) const
54860         {
54861                 v(protocolIEs);
54862
54863         };
54864         void clear()
54865         {
54866                 protocolIEs.clear();
54867
54868         };
54869         private:
54870         protocolIEs_t   protocolIEs;
54871
54872 };
54873 /*
54874 SeNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
54875         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
54876         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
54877         { ID id-E-RABs-SubjectToCounterCheck-List       CRITICALITY ignore      TYPE E-RABs-SubjectToCounterCheck-List          PRESENCE mandatory}|
54878         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
54879         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional},
54880         ...
54881 }
54882 */
54883
54884 struct SeNBCounterCheckRequest_IEs
54885 {
54886         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
54887         {
54888                 size_t get_index() const {return type;}
54889                 bool is_unknown() const { return type == 6; }
54890                 void clear() {type = 0;}
54891                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
54892                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
54893                 void select_id_E_RABs_SubjectToCounterCheck_List() { set(id_E_RABs_SubjectToCounterCheck_List); type=3;}
54894                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
54895                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
54896                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
54897                 template<typename V>  bool decode(V& v)
54898                 {
54899                         clear();
54900                         if(!v(ref_nested())) return false;
54901                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
54902                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
54903                         else if(equal(id_E_RABs_SubjectToCounterCheck_List)) { type = 3; return true; }
54904                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
54905                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
54906                         else { type = 6; return true;}
54907                         return false;
54908
54909                 }
54910                 template<typename V> bool encode(V& v) const
54911                 {
54912                         return v(ref_nested());
54913
54914                 }
54915                 protected:
54916                 template<typename V>  bool decode(size_t index, V& v)
54917                 {
54918                         clear();
54919                         switch(index)
54920                         {
54921                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
54922                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
54923                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToCounterCheck_List);} return false;
54924                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
54925                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
54926                         case 6: type = 6; return v(ref_nested());
54927                         ref_nested().clear();
54928                         }
54929                         return false;
54930
54931                 }
54932                 template<typename V> bool encode(size_t index, V& v) const
54933                 {
54934                         if(index != type) {return false;} return v(ref_nested());
54935
54936                 }
54937                 private:
54938                 size_t type {0};
54939
54940         };
54941         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
54942         {
54943                 size_t get_index() const {return type;}
54944                 bool is_unknown() const { return type == 6; }
54945                 void clear() {type = 0;}
54946                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
54947                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
54948                 void select_id_E_RABs_SubjectToCounterCheck_List() { set(ignore); type=3;}
54949                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
54950                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
54951                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
54952                 template<typename V>  bool decode(V& v)
54953                 {
54954                         clear();
54955                         if(!v(ref_nested())) return false;
54956                         if(equal(reject)) { type = 1; return true; }
54957                         else if(equal(reject)) { type = 2; return true; }
54958                         else if(equal(ignore)) { type = 3; return true; }
54959                         else if(equal(ignore)) { type = 4; return true; }
54960                         else if(equal(ignore)) { type = 5; return true; }
54961                         else { type = 6; return true;}
54962                         return false;
54963
54964                 }
54965                 template<typename V> bool encode(V& v) const
54966                 {
54967                         return v(ref_nested());
54968
54969                 }
54970                 protected:
54971                 template<typename V>  bool decode(size_t index, V& v)
54972                 {
54973                         clear();
54974                         switch(index)
54975                         {
54976                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
54977                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
54978                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
54979                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
54980                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
54981                         case 6: type = 6; return v(ref_nested());
54982                         ref_nested().clear();
54983                         }
54984                         return false;
54985
54986                 }
54987                 template<typename V> bool encode(size_t index, V& v) const
54988                 {
54989                         if(index != type) {return false;} return v(ref_nested());
54990
54991                 }
54992                 private:
54993                 size_t type {0};
54994
54995         };
54996         struct Value_t : asn::typefield<true>
54997         {
54998                 ~Value_t()      {clear();}
54999                 size_t get_index() const {return type;}
55000                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55001                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55002                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55003                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55004                 E_RABs_SubjectToCounterCheck_List& select_id_E_RABs_SubjectToCounterCheck_List() { return set<E_RABs_SubjectToCounterCheck_List>(3); }
55005                 E_RABs_SubjectToCounterCheck_List const* get_id_E_RABs_SubjectToCounterCheck_List() const { return get<E_RABs_SubjectToCounterCheck_List>(3); }
55006                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
55007                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
55008                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
55009                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
55010                 bool is_unknown() const { return type == 6; }
55011                 void clear()
55012                 {
55013                         switch(type)
55014                         {
55015                         case 1: var.destroy<UE_X2AP_ID>(); break;
55016                         case 2: var.destroy<UE_X2AP_ID>(); break;
55017                         case 3: var.destroy<E_RABs_SubjectToCounterCheck_List>(); break;
55018                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
55019                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
55020                         }
55021                         type = 0; ref_nested().clear();
55022                 }
55023                 template<typename V> static inline void enumerate(V& v)
55024                 {
55025                         v.template operator()<UE_X2AP_ID>(1);
55026                         v.template operator()<UE_X2AP_ID>(2);
55027                         v.template operator()<E_RABs_SubjectToCounterCheck_List>(3);
55028                         v.template operator()<UE_X2AP_ID_Extension>(4);
55029                         v.template operator()<UE_X2AP_ID_Extension>(5);
55030
55031                 }
55032                 protected:
55033                 template<typename V> bool decode(size_t index, V& v)
55034                 {
55035                         clear();
55036                         switch(index)
55037                         {
55038                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55039                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55040                         case 3: v(select_id_E_RABs_SubjectToCounterCheck_List()); return true;
55041                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55042                         case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55043                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
55044                         }
55045                         return false;
55046
55047                 }
55048                 template<typename V> bool encode(size_t index, V& v) const
55049                 {
55050                         if(index != type) return false;
55051                         switch(type)
55052                         {
55053                         case 1: v(var.as<UE_X2AP_ID>()); return true;
55054                         case 2: v(var.as<UE_X2AP_ID>()); return true;
55055                         case 3: v(var.as<E_RABs_SubjectToCounterCheck_List>()); return true;
55056                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
55057                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
55058                         }
55059                         return false;
55060
55061                 }
55062                 private:
55063                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55064                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55065                 union union_type
55066                 {
55067                         char dummy1[sizeof(E_RABs_SubjectToCounterCheck_List)];
55068                         char dummy2[sizeof(UE_X2AP_ID)];
55069                         char dummy3[sizeof(UE_X2AP_ID_Extension)];
55070
55071                 };
55072                 asn::variant<sizeof(union_type)> var;
55073                 size_t type {0};
55074
55075         };
55076         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55077         {
55078                 size_t get_index() const {return type;}
55079                 bool is_unknown() const { return type == 6; }
55080                 void clear() {type = 0;}
55081                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55082                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55083                 void select_id_E_RABs_SubjectToCounterCheck_List() { set(mandatory); type=3;}
55084                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
55085                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
55086                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55087                 template<typename V>  bool decode(V& v)
55088                 {
55089                         clear();
55090                         if(!v(ref_nested())) return false;
55091                         if(equal(mandatory)) { type = 1; return true; }
55092                         else if(equal(mandatory)) { type = 2; return true; }
55093                         else if(equal(mandatory)) { type = 3; return true; }
55094                         else if(equal(optional)) { type = 4; return true; }
55095                         else if(equal(optional)) { type = 5; return true; }
55096                         else { type = 6; return true;}
55097                         return false;
55098
55099                 }
55100                 template<typename V> bool encode(V& v) const
55101                 {
55102                         return v(ref_nested());
55103
55104                 }
55105                 protected:
55106                 template<typename V>  bool decode(size_t index, V& v)
55107                 {
55108                         clear();
55109                         switch(index)
55110                         {
55111                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55112                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55113                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
55114                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55115                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55116                         case 6: type = 6; return v(ref_nested());
55117                         ref_nested().clear();
55118                         }
55119                         return false;
55120
55121                 }
55122                 template<typename V> bool encode(size_t index, V& v) const
55123                 {
55124                         if(index != type) {return false;} return v(ref_nested());
55125
55126                 }
55127                 private:
55128                 size_t type {0};
55129
55130         };
55131
55132 };
55133 /*
55134 SeNBCounterCheckRequest ::= SEQUENCE {
55135         protocolIEs             ProtocolIE-Container    {{SeNBCounterCheckRequest-IEs}},
55136         ...
55137 }
55138 */
55139
55140 struct SeNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
55141 {
55142         static constexpr const char* name() {return "SeNBCounterCheckRequest";}
55143         using parent_t = asn::sequence<1, 0, true, 0>;
55144         struct protocolIEs_t : ProtocolIE_Container<SeNBCounterCheckRequest_IEs>
55145         {
55146                 static constexpr const char* name() {return "protocolIEs_t";}
55147                 using parent_t = ProtocolIE_Container<SeNBCounterCheckRequest_IEs>;
55148
55149         };
55150         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55151         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55152         template<typename V> void decode(V& v)
55153         {
55154                 v(protocolIEs);
55155
55156         };
55157         template<typename V> void encode(V& v) const
55158         {
55159                 v(protocolIEs);
55160
55161         };
55162         void clear()
55163         {
55164                 protocolIEs.clear();
55165
55166         };
55167         private:
55168         protocolIEs_t   protocolIEs;
55169
55170 };
55171 /*
55172 SeNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
55173         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                         PRESENCE mandatory}|
55174         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                         PRESENCE mandatory}|
55175         { ID id-MeNBtoSeNBContainer                                     CRITICALITY ignore      TYPE MeNBtoSeNBContainer                        PRESENCE optional}|
55176         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional}|
55177         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                       PRESENCE optional}|
55178         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                       PRESENCE optional},
55179         ...
55180 }
55181 */
55182
55183 struct SeNBModificationConfirm_IEs
55184 {
55185         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
55186         {
55187                 size_t get_index() const {return type;}
55188                 bool is_unknown() const { return type == 7; }
55189                 void clear() {type = 0;}
55190                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
55191                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
55192                 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=3;}
55193                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
55194                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
55195                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
55196                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
55197                 template<typename V>  bool decode(V& v)
55198                 {
55199                         clear();
55200                         if(!v(ref_nested())) return false;
55201                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
55202                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
55203                         else if(equal(id_MeNBtoSeNBContainer)) { type = 3; return true; }
55204                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
55205                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
55206                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
55207                         else { type = 7; return true;}
55208                         return false;
55209
55210                 }
55211                 template<typename V> bool encode(V& v) const
55212                 {
55213                         return v(ref_nested());
55214
55215                 }
55216                 protected:
55217                 template<typename V>  bool decode(size_t index, V& v)
55218                 {
55219                         clear();
55220                         switch(index)
55221                         {
55222                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
55223                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
55224                         case 3: type = 3; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
55225                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
55226                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
55227                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
55228                         case 7: type = 7; return v(ref_nested());
55229                         ref_nested().clear();
55230                         }
55231                         return false;
55232
55233                 }
55234                 template<typename V> bool encode(size_t index, V& v) const
55235                 {
55236                         if(index != type) {return false;} return v(ref_nested());
55237
55238                 }
55239                 private:
55240                 size_t type {0};
55241
55242         };
55243         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
55244         {
55245                 size_t get_index() const {return type;}
55246                 bool is_unknown() const { return type == 7; }
55247                 void clear() {type = 0;}
55248                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
55249                 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
55250                 void select_id_MeNBtoSeNBContainer() { set(ignore); type=3;}
55251                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
55252                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
55253                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
55254                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
55255                 template<typename V>  bool decode(V& v)
55256                 {
55257                         clear();
55258                         if(!v(ref_nested())) return false;
55259                         if(equal(ignore)) { type = 1; return true; }
55260                         else if(equal(ignore)) { type = 2; return true; }
55261                         else if(equal(ignore)) { type = 3; return true; }
55262                         else if(equal(ignore)) { type = 4; return true; }
55263                         else if(equal(ignore)) { type = 5; return true; }
55264                         else if(equal(ignore)) { type = 6; return true; }
55265                         else { type = 7; return true;}
55266                         return false;
55267
55268                 }
55269                 template<typename V> bool encode(V& v) const
55270                 {
55271                         return v(ref_nested());
55272
55273                 }
55274                 protected:
55275                 template<typename V>  bool decode(size_t index, V& v)
55276                 {
55277                         clear();
55278                         switch(index)
55279                         {
55280                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
55281                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
55282                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
55283                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
55284                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
55285                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
55286                         case 7: type = 7; return v(ref_nested());
55287                         ref_nested().clear();
55288                         }
55289                         return false;
55290
55291                 }
55292                 template<typename V> bool encode(size_t index, V& v) const
55293                 {
55294                         if(index != type) {return false;} return v(ref_nested());
55295
55296                 }
55297                 private:
55298                 size_t type {0};
55299
55300         };
55301         struct Value_t : asn::typefield<true>
55302         {
55303                 ~Value_t()      {clear();}
55304                 size_t get_index() const {return type;}
55305                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55306                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55307                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55308                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55309                 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(3); }
55310                 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(3); }
55311                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
55312                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
55313                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
55314                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
55315                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
55316                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
55317                 bool is_unknown() const { return type == 7; }
55318                 void clear()
55319                 {
55320                         switch(type)
55321                         {
55322                         case 1: var.destroy<UE_X2AP_ID>(); break;
55323                         case 2: var.destroy<UE_X2AP_ID>(); break;
55324                         case 3: var.destroy<MeNBtoSeNBContainer>(); break;
55325                         case 4: var.destroy<CriticalityDiagnostics>(); break;
55326                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
55327                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
55328                         }
55329                         type = 0; ref_nested().clear();
55330                 }
55331                 template<typename V> static inline void enumerate(V& v)
55332                 {
55333                         v.template operator()<UE_X2AP_ID>(1);
55334                         v.template operator()<UE_X2AP_ID>(2);
55335                         v.template operator()<MeNBtoSeNBContainer>(3);
55336                         v.template operator()<CriticalityDiagnostics>(4);
55337                         v.template operator()<UE_X2AP_ID_Extension>(5);
55338                         v.template operator()<UE_X2AP_ID_Extension>(6);
55339
55340                 }
55341                 protected:
55342                 template<typename V> bool decode(size_t index, V& v)
55343                 {
55344                         clear();
55345                         switch(index)
55346                         {
55347                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55348                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55349                         case 3: v(select_id_MeNBtoSeNBContainer()); return true;
55350                         case 4: v(select_id_CriticalityDiagnostics()); return true;
55351                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55352                         case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55353                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
55354                         }
55355                         return false;
55356
55357                 }
55358                 template<typename V> bool encode(size_t index, V& v) const
55359                 {
55360                         if(index != type) return false;
55361                         switch(type)
55362                         {
55363                         case 1: v(var.as<UE_X2AP_ID>()); return true;
55364                         case 2: v(var.as<UE_X2AP_ID>()); return true;
55365                         case 3: v(var.as<MeNBtoSeNBContainer>()); return true;
55366                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
55367                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
55368                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
55369                         }
55370                         return false;
55371
55372                 }
55373                 private:
55374                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55375                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55376                 union union_type
55377                 {
55378                         char dummy1[sizeof(CriticalityDiagnostics)];
55379                         char dummy2[sizeof(MeNBtoSeNBContainer)];
55380                         char dummy3[sizeof(UE_X2AP_ID)];
55381                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
55382
55383                 };
55384                 asn::variant<sizeof(union_type)> var;
55385                 size_t type {0};
55386
55387         };
55388         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55389         {
55390                 size_t get_index() const {return type;}
55391                 bool is_unknown() const { return type == 7; }
55392                 void clear() {type = 0;}
55393                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55394                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55395                 void select_id_MeNBtoSeNBContainer() { set(optional); type=3;}
55396                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
55397                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
55398                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
55399                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55400                 template<typename V>  bool decode(V& v)
55401                 {
55402                         clear();
55403                         if(!v(ref_nested())) return false;
55404                         if(equal(mandatory)) { type = 1; return true; }
55405                         else if(equal(mandatory)) { type = 2; return true; }
55406                         else if(equal(optional)) { type = 3; return true; }
55407                         else if(equal(optional)) { type = 4; return true; }
55408                         else if(equal(optional)) { type = 5; return true; }
55409                         else if(equal(optional)) { type = 6; return true; }
55410                         else { type = 7; return true;}
55411                         return false;
55412
55413                 }
55414                 template<typename V> bool encode(V& v) const
55415                 {
55416                         return v(ref_nested());
55417
55418                 }
55419                 protected:
55420                 template<typename V>  bool decode(size_t index, V& v)
55421                 {
55422                         clear();
55423                         switch(index)
55424                         {
55425                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55426                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55427                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
55428                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55429                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55430                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
55431                         case 7: type = 7; return v(ref_nested());
55432                         ref_nested().clear();
55433                         }
55434                         return false;
55435
55436                 }
55437                 template<typename V> bool encode(size_t index, V& v) const
55438                 {
55439                         if(index != type) {return false;} return v(ref_nested());
55440
55441                 }
55442                 private:
55443                 size_t type {0};
55444
55445         };
55446
55447 };
55448 /*
55449 SeNBModificationConfirm ::= SEQUENCE {
55450         protocolIEs             ProtocolIE-Container    {{SeNBModificationConfirm-IEs}},
55451         ...
55452 }
55453 */
55454
55455 struct SeNBModificationConfirm : asn::sequence<1, 0, true, 0>
55456 {
55457         static constexpr const char* name() {return "SeNBModificationConfirm";}
55458         using parent_t = asn::sequence<1, 0, true, 0>;
55459         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationConfirm_IEs>
55460         {
55461                 static constexpr const char* name() {return "protocolIEs_t";}
55462                 using parent_t = ProtocolIE_Container<SeNBModificationConfirm_IEs>;
55463
55464         };
55465         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55466         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55467         template<typename V> void decode(V& v)
55468         {
55469                 v(protocolIEs);
55470
55471         };
55472         template<typename V> void encode(V& v) const
55473         {
55474                 v(protocolIEs);
55475
55476         };
55477         void clear()
55478         {
55479                 protocolIEs.clear();
55480
55481         };
55482         private:
55483         protocolIEs_t   protocolIEs;
55484
55485 };
55486 /*
55487 SeNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
55488         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
55489         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
55490         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
55491         { ID id-MeNBtoSeNBContainer                                     CRITICALITY ignore      TYPE MeNBtoSeNBContainer                PRESENCE optional}|
55492         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
55493         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
55494         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
55495         ...
55496 }
55497 */
55498
55499 struct SeNBModificationRefuse_IEs
55500 {
55501         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
55502         {
55503                 size_t get_index() const {return type;}
55504                 bool is_unknown() const { return type == 8; }
55505                 void clear() {type = 0;}
55506                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
55507                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
55508                 void select_id_Cause() { set(id_Cause); type=3;}
55509                 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=4;}
55510                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
55511                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
55512                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
55513                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
55514                 template<typename V>  bool decode(V& v)
55515                 {
55516                         clear();
55517                         if(!v(ref_nested())) return false;
55518                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
55519                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
55520                         else if(equal(id_Cause)) { type = 3; return true; }
55521                         else if(equal(id_MeNBtoSeNBContainer)) { type = 4; return true; }
55522                         else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
55523                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
55524                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
55525                         else { type = 8; return true;}
55526                         return false;
55527
55528                 }
55529                 template<typename V> bool encode(V& v) const
55530                 {
55531                         return v(ref_nested());
55532
55533                 }
55534                 protected:
55535                 template<typename V>  bool decode(size_t index, V& v)
55536                 {
55537                         clear();
55538                         switch(index)
55539                         {
55540                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
55541                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
55542                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
55543                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
55544                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
55545                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
55546                         case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
55547                         case 8: type = 8; return v(ref_nested());
55548                         ref_nested().clear();
55549                         }
55550                         return false;
55551
55552                 }
55553                 template<typename V> bool encode(size_t index, V& v) const
55554                 {
55555                         if(index != type) {return false;} return v(ref_nested());
55556
55557                 }
55558                 private:
55559                 size_t type {0};
55560
55561         };
55562         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
55563         {
55564                 size_t get_index() const {return type;}
55565                 bool is_unknown() const { return type == 8; }
55566                 void clear() {type = 0;}
55567                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
55568                 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
55569                 void select_id_Cause() { set(ignore); type=3;}
55570                 void select_id_MeNBtoSeNBContainer() { set(ignore); type=4;}
55571                 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
55572                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
55573                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=7;}
55574                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
55575                 template<typename V>  bool decode(V& v)
55576                 {
55577                         clear();
55578                         if(!v(ref_nested())) return false;
55579                         if(equal(ignore)) { type = 1; return true; }
55580                         else if(equal(ignore)) { type = 2; return true; }
55581                         else if(equal(ignore)) { type = 3; return true; }
55582                         else if(equal(ignore)) { type = 4; return true; }
55583                         else if(equal(ignore)) { type = 5; return true; }
55584                         else if(equal(ignore)) { type = 6; return true; }
55585                         else if(equal(ignore)) { type = 7; return true; }
55586                         else { type = 8; return true;}
55587                         return false;
55588
55589                 }
55590                 template<typename V> bool encode(V& v) const
55591                 {
55592                         return v(ref_nested());
55593
55594                 }
55595                 protected:
55596                 template<typename V>  bool decode(size_t index, V& v)
55597                 {
55598                         clear();
55599                         switch(index)
55600                         {
55601                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
55602                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
55603                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
55604                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
55605                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
55606                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
55607                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
55608                         case 8: type = 8; return v(ref_nested());
55609                         ref_nested().clear();
55610                         }
55611                         return false;
55612
55613                 }
55614                 template<typename V> bool encode(size_t index, V& v) const
55615                 {
55616                         if(index != type) {return false;} return v(ref_nested());
55617
55618                 }
55619                 private:
55620                 size_t type {0};
55621
55622         };
55623         struct Value_t : asn::typefield<true>
55624         {
55625                 ~Value_t()      {clear();}
55626                 size_t get_index() const {return type;}
55627                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
55628                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
55629                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
55630                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
55631                 Cause& select_id_Cause() { return set<Cause>(3); }
55632                 Cause const* get_id_Cause() const { return get<Cause>(3); }
55633                 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(4); }
55634                 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(4); }
55635                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
55636                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
55637                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
55638                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
55639                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
55640                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
55641                 bool is_unknown() const { return type == 8; }
55642                 void clear()
55643                 {
55644                         switch(type)
55645                         {
55646                         case 1: var.destroy<UE_X2AP_ID>(); break;
55647                         case 2: var.destroy<UE_X2AP_ID>(); break;
55648                         case 3: var.destroy<Cause>(); break;
55649                         case 4: var.destroy<MeNBtoSeNBContainer>(); break;
55650                         case 5: var.destroy<CriticalityDiagnostics>(); break;
55651                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
55652                         case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
55653                         }
55654                         type = 0; ref_nested().clear();
55655                 }
55656                 template<typename V> static inline void enumerate(V& v)
55657                 {
55658                         v.template operator()<UE_X2AP_ID>(1);
55659                         v.template operator()<UE_X2AP_ID>(2);
55660                         v.template operator()<Cause>(3);
55661                         v.template operator()<MeNBtoSeNBContainer>(4);
55662                         v.template operator()<CriticalityDiagnostics>(5);
55663                         v.template operator()<UE_X2AP_ID_Extension>(6);
55664                         v.template operator()<UE_X2AP_ID_Extension>(7);
55665
55666                 }
55667                 protected:
55668                 template<typename V> bool decode(size_t index, V& v)
55669                 {
55670                         clear();
55671                         switch(index)
55672                         {
55673                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
55674                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
55675                         case 3: v(select_id_Cause()); return true;
55676                         case 4: v(select_id_MeNBtoSeNBContainer()); return true;
55677                         case 5: v(select_id_CriticalityDiagnostics()); return true;
55678                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
55679                         case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
55680                         case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
55681                         }
55682                         return false;
55683
55684                 }
55685                 template<typename V> bool encode(size_t index, V& v) const
55686                 {
55687                         if(index != type) return false;
55688                         switch(type)
55689                         {
55690                         case 1: v(var.as<UE_X2AP_ID>()); return true;
55691                         case 2: v(var.as<UE_X2AP_ID>()); return true;
55692                         case 3: v(var.as<Cause>()); return true;
55693                         case 4: v(var.as<MeNBtoSeNBContainer>()); return true;
55694                         case 5: v(var.as<CriticalityDiagnostics>()); return true;
55695                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
55696                         case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
55697                         }
55698                         return false;
55699
55700                 }
55701                 private:
55702                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
55703                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
55704                 union union_type
55705                 {
55706                         char dummy1[sizeof(Cause)];
55707                         char dummy2[sizeof(CriticalityDiagnostics)];
55708                         char dummy3[sizeof(MeNBtoSeNBContainer)];
55709                         char dummy4[sizeof(UE_X2AP_ID)];
55710                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
55711
55712                 };
55713                 asn::variant<sizeof(union_type)> var;
55714                 size_t type {0};
55715
55716         };
55717         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
55718         {
55719                 size_t get_index() const {return type;}
55720                 bool is_unknown() const { return type == 8; }
55721                 void clear() {type = 0;}
55722                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
55723                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
55724                 void select_id_Cause() { set(mandatory); type=3;}
55725                 void select_id_MeNBtoSeNBContainer() { set(optional); type=4;}
55726                 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
55727                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
55728                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
55729                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
55730                 template<typename V>  bool decode(V& v)
55731                 {
55732                         clear();
55733                         if(!v(ref_nested())) return false;
55734                         if(equal(mandatory)) { type = 1; return true; }
55735                         else if(equal(mandatory)) { type = 2; return true; }
55736                         else if(equal(mandatory)) { type = 3; return true; }
55737                         else if(equal(optional)) { type = 4; return true; }
55738                         else if(equal(optional)) { type = 5; return true; }
55739                         else if(equal(optional)) { type = 6; return true; }
55740                         else if(equal(optional)) { type = 7; return true; }
55741                         else { type = 8; return true;}
55742                         return false;
55743
55744                 }
55745                 template<typename V> bool encode(V& v) const
55746                 {
55747                         return v(ref_nested());
55748
55749                 }
55750                 protected:
55751                 template<typename V>  bool decode(size_t index, V& v)
55752                 {
55753                         clear();
55754                         switch(index)
55755                         {
55756                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
55757                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
55758                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
55759                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
55760                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
55761                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
55762                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
55763                         case 8: type = 8; return v(ref_nested());
55764                         ref_nested().clear();
55765                         }
55766                         return false;
55767
55768                 }
55769                 template<typename V> bool encode(size_t index, V& v) const
55770                 {
55771                         if(index != type) {return false;} return v(ref_nested());
55772
55773                 }
55774                 private:
55775                 size_t type {0};
55776
55777         };
55778
55779 };
55780 /*
55781 SeNBModificationRefuse ::= SEQUENCE {
55782         protocolIEs             ProtocolIE-Container            {{SeNBModificationRefuse-IEs}},
55783         ...
55784 }
55785 */
55786
55787 struct SeNBModificationRefuse : asn::sequence<1, 0, true, 0>
55788 {
55789         static constexpr const char* name() {return "SeNBModificationRefuse";}
55790         using parent_t = asn::sequence<1, 0, true, 0>;
55791         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRefuse_IEs>
55792         {
55793                 static constexpr const char* name() {return "protocolIEs_t";}
55794                 using parent_t = ProtocolIE_Container<SeNBModificationRefuse_IEs>;
55795
55796         };
55797         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
55798         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
55799         template<typename V> void decode(V& v)
55800         {
55801                 v(protocolIEs);
55802
55803         };
55804         template<typename V> void encode(V& v) const
55805         {
55806                 v(protocolIEs);
55807
55808         };
55809         void clear()
55810         {
55811                 protocolIEs.clear();
55812
55813         };
55814         private:
55815         protocolIEs_t   protocolIEs;
55816
55817 };
55818 /*
55819 UE-ContextInformationSeNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
55820         ...
55821 }
55822 */
55823
55824 struct UE_ContextInformationSeNBModReqExtIEs
55825 {
55826         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
55827         {
55828                 size_t get_index() const {return type;}
55829                 bool is_unknown() const { return type == 1; }
55830                 void clear() {type = 0;}
55831                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
55832                 template<typename V>  bool decode(V& v)
55833                 {
55834                         clear();
55835                         if(!v(ref_nested())) return false;
55836                         { type = 1; return true;}
55837                         return false;
55838
55839                 }
55840                 template<typename V> bool encode(V& v) const
55841                 {
55842                         return v(ref_nested());
55843
55844                 }
55845                 protected:
55846                 template<typename V>  bool decode(size_t index, V& v)
55847                 {
55848                         clear();
55849                         switch(index)
55850                         {
55851                         case 1: type = 1; return v(ref_nested());
55852                         ref_nested().clear();
55853                         }
55854                         return false;
55855
55856                 }
55857                 template<typename V> bool encode(size_t index, V& v) const
55858                 {
55859                         if(index != type) {return false;} return v(ref_nested());
55860
55861                 }
55862                 private:
55863                 size_t type {0};
55864
55865         };
55866         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
55867         {
55868                 size_t get_index() const {return type;}
55869                 bool is_unknown() const { return type == 1; }
55870                 void clear() {type = 0;}
55871                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
55872                 template<typename V>  bool decode(V& v)
55873                 {
55874                         clear();
55875                         if(!v(ref_nested())) return false;
55876                         { type = 1; return true;}
55877                         return false;
55878
55879                 }
55880                 template<typename V> bool encode(V& v) const
55881                 {
55882                         return v(ref_nested());
55883
55884                 }
55885                 protected:
55886                 template<typename V>  bool decode(size_t index, V& v)
55887                 {
55888                         clear();
55889                         switch(index)
55890                         {
55891                         case 1: type = 1; return v(ref_nested());
55892                         ref_nested().clear();
55893                         }
55894                         return false;
55895
55896                 }
55897                 template<typename V> bool encode(size_t index, V& v) const
55898                 {
55899                         if(index != type) {return false;} return v(ref_nested());
55900
55901                 }
55902                 private:
55903                 size_t type {0};
55904
55905         };
55906         struct Extension_t : asn::typefield<true>
55907         {
55908                 ~Extension_t()  {clear();}
55909                 size_t get_index() const {return type;}
55910                 bool is_unknown() const { return type == 1; }
55911                 void clear()
55912                 {
55913                         type = 0; ref_nested().clear();
55914                 }
55915                 template<typename V> static inline void enumerate(V& v)
55916                 {
55917
55918                 }
55919                 protected:
55920                 template<typename V> bool decode(size_t index, V& v)
55921                 {
55922                         clear();
55923                         switch(index)
55924                         {
55925                         case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
55926                         }
55927                         return false;
55928
55929                 }
55930                 template<typename V> bool encode(size_t index, V& v) const
55931                 {
55932                         if(index != type) return false;
55933                         return false;
55934
55935                 }
55936                 private:
55937                 size_t type {0};
55938
55939         };
55940         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
55941         {
55942                 size_t get_index() const {return type;}
55943                 bool is_unknown() const { return type == 1; }
55944                 void clear() {type = 0;}
55945                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
55946                 template<typename V>  bool decode(V& v)
55947                 {
55948                         clear();
55949                         if(!v(ref_nested())) return false;
55950                         { type = 1; return true;}
55951                         return false;
55952
55953                 }
55954                 template<typename V> bool encode(V& v) const
55955                 {
55956                         return v(ref_nested());
55957
55958                 }
55959                 protected:
55960                 template<typename V>  bool decode(size_t index, V& v)
55961                 {
55962                         clear();
55963                         switch(index)
55964                         {
55965                         case 1: type = 1; return v(ref_nested());
55966                         ref_nested().clear();
55967                         }
55968                         return false;
55969
55970                 }
55971                 template<typename V> bool encode(size_t index, V& v) const
55972                 {
55973                         if(index != type) {return false;} return v(ref_nested());
55974
55975                 }
55976                 private:
55977                 size_t type {0};
55978
55979         };
55980
55981 };
55982 /*
55983 UE-ContextInformationSeNBModReq ::= SEQUENCE {
55984         uE-SecurityCapabilities                 UESecurityCapabilities                                                                                                                  OPTIONAL,
55985         seNB-SecurityKey                                SeNBSecurityKey                                                                                                                                 OPTIONAL,
55986         seNBUEAggregateMaximumBitRate   UEAggregateMaximumBitRate                                                                                                               OPTIONAL,
55987         e-RABs-ToBeAdded                                E-RABs-ToBeAdded-List-ModReq                                                                                                    OPTIONAL,
55988         e-RABs-ToBeModified                             E-RABs-ToBeModified-List-ModReq                                                                                                 OPTIONAL,
55989         e-RABs-ToBeReleased                             E-RABs-ToBeReleased-List-ModReq                                                                                                 OPTIONAL,
55990         iE-Extensions                                   ProtocolExtensionContainer { {UE-ContextInformationSeNBModReqExtIEs} }  OPTIONAL,
55991         ...
55992 }
55993 */
55994
55995 struct UE_ContextInformationSeNBModReq : asn::sequence<7, 0, true, 7>
55996 {
55997         static constexpr const char* name() {return "UE-ContextInformationSeNBModReq";}
55998         using parent_t = asn::sequence<7, 0, true, 7>;
55999         struct uE_SecurityCapabilities_t : UESecurityCapabilities
56000         {
56001                 static constexpr const char* name() {return "uE_SecurityCapabilities_t";}
56002                 using parent_t = UESecurityCapabilities;
56003                 static constexpr bool optional = true;
56004
56005         };
56006         uE_SecurityCapabilities_t& set_uE_SecurityCapabilities() { uE_SecurityCapabilities.setpresent(true); return uE_SecurityCapabilities;}
56007         uE_SecurityCapabilities_t const* get_uE_SecurityCapabilities() const {return uE_SecurityCapabilities.is_valid() ? &uE_SecurityCapabilities : nullptr;}
56008         struct seNB_SecurityKey_t : SeNBSecurityKey
56009         {
56010                 static constexpr const char* name() {return "seNB_SecurityKey_t";}
56011                 using parent_t = SeNBSecurityKey;
56012                 static constexpr bool optional = true;
56013
56014         };
56015         seNB_SecurityKey_t& set_seNB_SecurityKey() { seNB_SecurityKey.setpresent(true); return seNB_SecurityKey;}
56016         seNB_SecurityKey_t const* get_seNB_SecurityKey() const {return seNB_SecurityKey.is_valid() ? &seNB_SecurityKey : nullptr;}
56017         struct seNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
56018         {
56019                 static constexpr const char* name() {return "seNBUEAggregateMaximumBitRate_t";}
56020                 using parent_t = UEAggregateMaximumBitRate;
56021                 static constexpr bool optional = true;
56022
56023         };
56024         seNBUEAggregateMaximumBitRate_t& set_seNBUEAggregateMaximumBitRate() { seNBUEAggregateMaximumBitRate.setpresent(true); return seNBUEAggregateMaximumBitRate;}
56025         seNBUEAggregateMaximumBitRate_t const* get_seNBUEAggregateMaximumBitRate() const {return seNBUEAggregateMaximumBitRate.is_valid() ? &seNBUEAggregateMaximumBitRate : nullptr;}
56026         struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_List_ModReq
56027         {
56028                 static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
56029                 using parent_t = E_RABs_ToBeAdded_List_ModReq;
56030                 static constexpr bool optional = true;
56031
56032         };
56033         e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
56034         e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
56035         struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_List_ModReq
56036         {
56037                 static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
56038                 using parent_t = E_RABs_ToBeModified_List_ModReq;
56039                 static constexpr bool optional = true;
56040
56041         };
56042         e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
56043         e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
56044         struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_List_ModReq
56045         {
56046                 static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
56047                 using parent_t = E_RABs_ToBeReleased_List_ModReq;
56048                 static constexpr bool optional = true;
56049
56050         };
56051         e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
56052         e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
56053         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>
56054         {
56055                 static constexpr const char* name() {return "iE_Extensions_t";}
56056                 using parent_t = ProtocolExtensionContainer<UE_ContextInformationSeNBModReqExtIEs>;
56057                 static constexpr bool optional = true;
56058
56059         };
56060         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
56061         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
56062         template<typename V> void decode(V& v)
56063         {
56064                 v(uE_SecurityCapabilities);
56065                 v(seNB_SecurityKey);
56066                 v(seNBUEAggregateMaximumBitRate);
56067                 v(e_RABs_ToBeAdded);
56068                 v(e_RABs_ToBeModified);
56069                 v(e_RABs_ToBeReleased);
56070                 v(iE_Extensions);
56071
56072         };
56073         template<typename V> void encode(V& v) const
56074         {
56075                 v(uE_SecurityCapabilities);
56076                 v(seNB_SecurityKey);
56077                 v(seNBUEAggregateMaximumBitRate);
56078                 v(e_RABs_ToBeAdded);
56079                 v(e_RABs_ToBeModified);
56080                 v(e_RABs_ToBeReleased);
56081                 v(iE_Extensions);
56082
56083         };
56084         void clear()
56085         {
56086                 uE_SecurityCapabilities.clear();
56087                 seNB_SecurityKey.clear();
56088                 seNBUEAggregateMaximumBitRate.clear();
56089                 e_RABs_ToBeAdded.clear();
56090                 e_RABs_ToBeModified.clear();
56091                 e_RABs_ToBeReleased.clear();
56092                 iE_Extensions.clear();
56093
56094         };
56095         private:
56096         uE_SecurityCapabilities_t       uE_SecurityCapabilities;
56097         seNB_SecurityKey_t      seNB_SecurityKey;
56098         seNBUEAggregateMaximumBitRate_t seNBUEAggregateMaximumBitRate;
56099         e_RABs_ToBeAdded_t      e_RABs_ToBeAdded;
56100         e_RABs_ToBeModified_t   e_RABs_ToBeModified;
56101         e_RABs_ToBeReleased_t   e_RABs_ToBeReleased;
56102         iE_Extensions_t iE_Extensions;
56103
56104 };
56105 /*
56106 SeNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
56107         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                         PRESENCE mandatory}|
56108         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                         PRESENCE mandatory}|
56109         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                                                      PRESENCE mandatory}|
56110         { ID id-SCGChangeIndication                                     CRITICALITY ignore      TYPE SCGChangeIndication                                        PRESENCE optional}|
56111         { ID id-ServingPLMN                                                     CRITICALITY ignore      TYPE PLMN-Identity                                                      PRESENCE optional}|
56112         { ID id-UE-ContextInformationSeNBModReq         CRITICALITY reject      TYPE UE-ContextInformationSeNBModReq    PRESENCE optional}|
56113         { ID id-MeNBtoSeNBContainer                                     CRITICALITY ignore      TYPE MeNBtoSeNBContainer                                        PRESENCE optional}|
56114         { ID id-CSGMembershipStatus                                     CRITICALITY reject      TYPE CSGMembershipStatus                                        PRESENCE optional}|
56115         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                       PRESENCE optional}|
56116         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                       PRESENCE optional},
56117         ...
56118 }
56119 */
56120
56121 struct SeNBModificationRequest_IEs
56122 {
56123         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56124         {
56125                 size_t get_index() const {return type;}
56126                 bool is_unknown() const { return type == 11; }
56127                 void clear() {type = 0;}
56128                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56129                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56130                 void select_id_Cause() { set(id_Cause); type=3;}
56131                 void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
56132                 void select_id_ServingPLMN() { set(id_ServingPLMN); type=5;}
56133                 void select_id_UE_ContextInformationSeNBModReq() { set(id_UE_ContextInformationSeNBModReq); type=6;}
56134                 void select_id_MeNBtoSeNBContainer() { set(id_MeNBtoSeNBContainer); type=7;}
56135                 void select_id_CSGMembershipStatus() { set(id_CSGMembershipStatus); type=8;}
56136                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
56137                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
56138                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56139                 template<typename V>  bool decode(V& v)
56140                 {
56141                         clear();
56142                         if(!v(ref_nested())) return false;
56143                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56144                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56145                         else if(equal(id_Cause)) { type = 3; return true; }
56146                         else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
56147                         else if(equal(id_ServingPLMN)) { type = 5; return true; }
56148                         else if(equal(id_UE_ContextInformationSeNBModReq)) { type = 6; return true; }
56149                         else if(equal(id_MeNBtoSeNBContainer)) { type = 7; return true; }
56150                         else if(equal(id_CSGMembershipStatus)) { type = 8; return true; }
56151                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
56152                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
56153                         else { type = 11; return true;}
56154                         return false;
56155
56156                 }
56157                 template<typename V> bool encode(V& v) const
56158                 {
56159                         return v(ref_nested());
56160
56161                 }
56162                 protected:
56163                 template<typename V>  bool decode(size_t index, V& v)
56164                 {
56165                         clear();
56166                         switch(index)
56167                         {
56168                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56169                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56170                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
56171                         case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
56172                         case 5: type = 5; if(v(ref_nested())) { return equal(id_ServingPLMN);} return false;
56173                         case 6: type = 6; if(v(ref_nested())) { return equal(id_UE_ContextInformationSeNBModReq);} return false;
56174                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSeNBContainer);} return false;
56175                         case 8: type = 8; if(v(ref_nested())) { return equal(id_CSGMembershipStatus);} return false;
56176                         case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56177                         case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56178                         case 11: type = 11; return v(ref_nested());
56179                         ref_nested().clear();
56180                         }
56181                         return false;
56182
56183                 }
56184                 template<typename V> bool encode(size_t index, V& v) const
56185                 {
56186                         if(index != type) {return false;} return v(ref_nested());
56187
56188                 }
56189                 private:
56190                 size_t type {0};
56191
56192         };
56193         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56194         {
56195                 size_t get_index() const {return type;}
56196                 bool is_unknown() const { return type == 11; }
56197                 void clear() {type = 0;}
56198                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
56199                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
56200                 void select_id_Cause() { set(ignore); type=3;}
56201                 void select_id_SCGChangeIndication() { set(ignore); type=4;}
56202                 void select_id_ServingPLMN() { set(ignore); type=5;}
56203                 void select_id_UE_ContextInformationSeNBModReq() { set(reject); type=6;}
56204                 void select_id_MeNBtoSeNBContainer() { set(ignore); type=7;}
56205                 void select_id_CSGMembershipStatus() { set(reject); type=8;}
56206                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
56207                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=10;}
56208                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56209                 template<typename V>  bool decode(V& v)
56210                 {
56211                         clear();
56212                         if(!v(ref_nested())) return false;
56213                         if(equal(reject)) { type = 1; return true; }
56214                         else if(equal(reject)) { type = 2; return true; }
56215                         else if(equal(ignore)) { type = 3; return true; }
56216                         else if(equal(ignore)) { type = 4; return true; }
56217                         else if(equal(ignore)) { type = 5; return true; }
56218                         else if(equal(reject)) { type = 6; return true; }
56219                         else if(equal(ignore)) { type = 7; return true; }
56220                         else if(equal(reject)) { type = 8; return true; }
56221                         else if(equal(reject)) { type = 9; return true; }
56222                         else if(equal(reject)) { type = 10; return true; }
56223                         else { type = 11; return true;}
56224                         return false;
56225
56226                 }
56227                 template<typename V> bool encode(V& v) const
56228                 {
56229                         return v(ref_nested());
56230
56231                 }
56232                 protected:
56233                 template<typename V>  bool decode(size_t index, V& v)
56234                 {
56235                         clear();
56236                         switch(index)
56237                         {
56238                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
56239                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
56240                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56241                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56242                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56243                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
56244                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
56245                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
56246                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
56247                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
56248                         case 11: type = 11; return v(ref_nested());
56249                         ref_nested().clear();
56250                         }
56251                         return false;
56252
56253                 }
56254                 template<typename V> bool encode(size_t index, V& v) const
56255                 {
56256                         if(index != type) {return false;} return v(ref_nested());
56257
56258                 }
56259                 private:
56260                 size_t type {0};
56261
56262         };
56263         struct Value_t : asn::typefield<true>
56264         {
56265                 ~Value_t()      {clear();}
56266                 size_t get_index() const {return type;}
56267                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
56268                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
56269                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
56270                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
56271                 Cause& select_id_Cause() { return set<Cause>(3); }
56272                 Cause const* get_id_Cause() const { return get<Cause>(3); }
56273                 SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
56274                 SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
56275                 PLMN_Identity& select_id_ServingPLMN() { return set<PLMN_Identity>(5); }
56276                 PLMN_Identity const* get_id_ServingPLMN() const { return get<PLMN_Identity>(5); }
56277                 UE_ContextInformationSeNBModReq& select_id_UE_ContextInformationSeNBModReq() { return set<UE_ContextInformationSeNBModReq>(6); }
56278                 UE_ContextInformationSeNBModReq const* get_id_UE_ContextInformationSeNBModReq() const { return get<UE_ContextInformationSeNBModReq>(6); }
56279                 MeNBtoSeNBContainer& select_id_MeNBtoSeNBContainer() { return set<MeNBtoSeNBContainer>(7); }
56280                 MeNBtoSeNBContainer const* get_id_MeNBtoSeNBContainer() const { return get<MeNBtoSeNBContainer>(7); }
56281                 CSGMembershipStatus& select_id_CSGMembershipStatus() { return set<CSGMembershipStatus>(8); }
56282                 CSGMembershipStatus const* get_id_CSGMembershipStatus() const { return get<CSGMembershipStatus>(8); }
56283                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
56284                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
56285                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
56286                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
56287                 bool is_unknown() const { return type == 11; }
56288                 void clear()
56289                 {
56290                         switch(type)
56291                         {
56292                         case 1: var.destroy<UE_X2AP_ID>(); break;
56293                         case 2: var.destroy<UE_X2AP_ID>(); break;
56294                         case 3: var.destroy<Cause>(); break;
56295                         case 4: var.destroy<SCGChangeIndication>(); break;
56296                         case 5: var.destroy<PLMN_Identity>(); break;
56297                         case 6: var.destroy<UE_ContextInformationSeNBModReq>(); break;
56298                         case 7: var.destroy<MeNBtoSeNBContainer>(); break;
56299                         case 8: var.destroy<CSGMembershipStatus>(); break;
56300                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
56301                         case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
56302                         }
56303                         type = 0; ref_nested().clear();
56304                 }
56305                 template<typename V> static inline void enumerate(V& v)
56306                 {
56307                         v.template operator()<UE_X2AP_ID>(1);
56308                         v.template operator()<UE_X2AP_ID>(2);
56309                         v.template operator()<Cause>(3);
56310                         v.template operator()<SCGChangeIndication>(4);
56311                         v.template operator()<PLMN_Identity>(5);
56312                         v.template operator()<UE_ContextInformationSeNBModReq>(6);
56313                         v.template operator()<MeNBtoSeNBContainer>(7);
56314                         v.template operator()<CSGMembershipStatus>(8);
56315                         v.template operator()<UE_X2AP_ID_Extension>(9);
56316                         v.template operator()<UE_X2AP_ID_Extension>(10);
56317
56318                 }
56319                 protected:
56320                 template<typename V> bool decode(size_t index, V& v)
56321                 {
56322                         clear();
56323                         switch(index)
56324                         {
56325                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
56326                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
56327                         case 3: v(select_id_Cause()); return true;
56328                         case 4: v(select_id_SCGChangeIndication()); return true;
56329                         case 5: v(select_id_ServingPLMN()); return true;
56330                         case 6: v(select_id_UE_ContextInformationSeNBModReq()); return true;
56331                         case 7: v(select_id_MeNBtoSeNBContainer()); return true;
56332                         case 8: v(select_id_CSGMembershipStatus()); return true;
56333                         case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
56334                         case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
56335                         case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
56336                         }
56337                         return false;
56338
56339                 }
56340                 template<typename V> bool encode(size_t index, V& v) const
56341                 {
56342                         if(index != type) return false;
56343                         switch(type)
56344                         {
56345                         case 1: v(var.as<UE_X2AP_ID>()); return true;
56346                         case 2: v(var.as<UE_X2AP_ID>()); return true;
56347                         case 3: v(var.as<Cause>()); return true;
56348                         case 4: v(var.as<SCGChangeIndication>()); return true;
56349                         case 5: v(var.as<PLMN_Identity>()); return true;
56350                         case 6: v(var.as<UE_ContextInformationSeNBModReq>()); return true;
56351                         case 7: v(var.as<MeNBtoSeNBContainer>()); return true;
56352                         case 8: v(var.as<CSGMembershipStatus>()); return true;
56353                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
56354                         case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
56355                         }
56356                         return false;
56357
56358                 }
56359                 private:
56360                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
56361                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
56362                 union union_type
56363                 {
56364                         char dummy1[sizeof(CSGMembershipStatus)];
56365                         char dummy2[sizeof(Cause)];
56366                         char dummy3[sizeof(MeNBtoSeNBContainer)];
56367                         char dummy4[sizeof(PLMN_Identity)];
56368                         char dummy5[sizeof(SCGChangeIndication)];
56369                         char dummy6[sizeof(UE_ContextInformationSeNBModReq)];
56370                         char dummy7[sizeof(UE_X2AP_ID)];
56371                         char dummy8[sizeof(UE_X2AP_ID_Extension)];
56372
56373                 };
56374                 asn::variant<sizeof(union_type)> var;
56375                 size_t type {0};
56376
56377         };
56378         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
56379         {
56380                 size_t get_index() const {return type;}
56381                 bool is_unknown() const { return type == 11; }
56382                 void clear() {type = 0;}
56383                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
56384                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
56385                 void select_id_Cause() { set(mandatory); type=3;}
56386                 void select_id_SCGChangeIndication() { set(optional); type=4;}
56387                 void select_id_ServingPLMN() { set(optional); type=5;}
56388                 void select_id_UE_ContextInformationSeNBModReq() { set(optional); type=6;}
56389                 void select_id_MeNBtoSeNBContainer() { set(optional); type=7;}
56390                 void select_id_CSGMembershipStatus() { set(optional); type=8;}
56391                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
56392                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
56393                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
56394                 template<typename V>  bool decode(V& v)
56395                 {
56396                         clear();
56397                         if(!v(ref_nested())) return false;
56398                         if(equal(mandatory)) { type = 1; return true; }
56399                         else if(equal(mandatory)) { type = 2; return true; }
56400                         else if(equal(mandatory)) { type = 3; return true; }
56401                         else if(equal(optional)) { type = 4; return true; }
56402                         else if(equal(optional)) { type = 5; return true; }
56403                         else if(equal(optional)) { type = 6; return true; }
56404                         else if(equal(optional)) { type = 7; return true; }
56405                         else if(equal(optional)) { type = 8; return true; }
56406                         else if(equal(optional)) { type = 9; return true; }
56407                         else if(equal(optional)) { type = 10; return true; }
56408                         else { type = 11; return true;}
56409                         return false;
56410
56411                 }
56412                 template<typename V> bool encode(V& v) const
56413                 {
56414                         return v(ref_nested());
56415
56416                 }
56417                 protected:
56418                 template<typename V>  bool decode(size_t index, V& v)
56419                 {
56420                         clear();
56421                         switch(index)
56422                         {
56423                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
56424                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
56425                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
56426                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
56427                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
56428                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
56429                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
56430                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
56431                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
56432                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
56433                         case 11: type = 11; return v(ref_nested());
56434                         ref_nested().clear();
56435                         }
56436                         return false;
56437
56438                 }
56439                 template<typename V> bool encode(size_t index, V& v) const
56440                 {
56441                         if(index != type) {return false;} return v(ref_nested());
56442
56443                 }
56444                 private:
56445                 size_t type {0};
56446
56447         };
56448
56449 };
56450 /*
56451 SeNBModificationRequest ::= SEQUENCE {
56452         protocolIEs             ProtocolIE-Container    {{ SeNBModificationRequest-IEs}},
56453         ...
56454 }
56455 */
56456
56457 struct SeNBModificationRequest : asn::sequence<1, 0, true, 0>
56458 {
56459         static constexpr const char* name() {return "SeNBModificationRequest";}
56460         using parent_t = asn::sequence<1, 0, true, 0>;
56461         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequest_IEs>
56462         {
56463                 static constexpr const char* name() {return "protocolIEs_t";}
56464                 using parent_t = ProtocolIE_Container<SeNBModificationRequest_IEs>;
56465
56466         };
56467         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
56468         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
56469         template<typename V> void decode(V& v)
56470         {
56471                 v(protocolIEs);
56472
56473         };
56474         template<typename V> void encode(V& v) const
56475         {
56476                 v(protocolIEs);
56477
56478         };
56479         void clear()
56480         {
56481                 protocolIEs.clear();
56482
56483         };
56484         private:
56485         protocolIEs_t   protocolIEs;
56486
56487 };
56488 /*
56489 SeNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
56490         { ID id-MeNB-UE-X2AP-ID                                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
56491         { ID id-SeNB-UE-X2AP-ID                                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
56492         { ID id-E-RABs-Admitted-ToBeAdded-ModAckList            CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-ModAckList               PRESENCE optional}|
56493         { ID id-E-RABs-Admitted-ToBeModified-ModAckList         CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeModified-ModAckList    PRESENCE optional}|
56494         { ID id-E-RABs-Admitted-ToBeReleased-ModAckList         CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeReleased-ModAckList    PRESENCE optional}|
56495         { ID id-E-RABs-NotAdmitted-List                                         CRITICALITY ignore      TYPE E-RAB-List                                                                                 PRESENCE optional}|
56496         { ID id-SeNBtoMeNBContainer                                                     CRITICALITY ignore      TYPE SeNBtoMeNBContainer                                                                PRESENCE optional}|
56497         { ID id-CriticalityDiagnostics                                          CRITICALITY ignore      TYPE CriticalityDiagnostics                                                     PRESENCE optional}|
56498         { ID id-MeNB-UE-X2AP-ID-Extension                                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
56499         { ID id-SeNB-UE-X2AP-ID-Extension                                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional},
56500         ...
56501 }
56502 */
56503
56504 struct SeNBModificationRequestAcknowledge_IEs
56505 {
56506         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56507         {
56508                 size_t get_index() const {return type;}
56509                 bool is_unknown() const { return type == 11; }
56510                 void clear() {type = 0;}
56511                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56512                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56513                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(id_E_RABs_Admitted_ToBeAdded_ModAckList); type=3;}
56514                 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(id_E_RABs_Admitted_ToBeModified_ModAckList); type=4;}
56515                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(id_E_RABs_Admitted_ToBeReleased_ModAckList); type=5;}
56516                 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
56517                 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=7;}
56518                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
56519                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
56520                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=10;}
56521                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56522                 template<typename V>  bool decode(V& v)
56523                 {
56524                         clear();
56525                         if(!v(ref_nested())) return false;
56526                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56527                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56528                         else if(equal(id_E_RABs_Admitted_ToBeAdded_ModAckList)) { type = 3; return true; }
56529                         else if(equal(id_E_RABs_Admitted_ToBeModified_ModAckList)) { type = 4; return true; }
56530                         else if(equal(id_E_RABs_Admitted_ToBeReleased_ModAckList)) { type = 5; return true; }
56531                         else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
56532                         else if(equal(id_SeNBtoMeNBContainer)) { type = 7; return true; }
56533                         else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
56534                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
56535                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 10; return true; }
56536                         else { type = 11; return true;}
56537                         return false;
56538
56539                 }
56540                 template<typename V> bool encode(V& v) const
56541                 {
56542                         return v(ref_nested());
56543
56544                 }
56545                 protected:
56546                 template<typename V>  bool decode(size_t index, V& v)
56547                 {
56548                         clear();
56549                         switch(index)
56550                         {
56551                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56552                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56553                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_ModAckList);} return false;
56554                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_ModAckList);} return false;
56555                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_ModAckList);} return false;
56556                         case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
56557                         case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
56558                         case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
56559                         case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56560                         case 10: type = 10; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56561                         case 11: type = 11; return v(ref_nested());
56562                         ref_nested().clear();
56563                         }
56564                         return false;
56565
56566                 }
56567                 template<typename V> bool encode(size_t index, V& v) const
56568                 {
56569                         if(index != type) {return false;} return v(ref_nested());
56570
56571                 }
56572                 private:
56573                 size_t type {0};
56574
56575         };
56576         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56577         {
56578                 size_t get_index() const {return type;}
56579                 bool is_unknown() const { return type == 11; }
56580                 void clear() {type = 0;}
56581                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
56582                 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
56583                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(ignore); type=3;}
56584                 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(ignore); type=4;}
56585                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(ignore); type=5;}
56586                 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
56587                 void select_id_SeNBtoMeNBContainer() { set(ignore); type=7;}
56588                 void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
56589                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
56590                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=10;}
56591                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56592                 template<typename V>  bool decode(V& v)
56593                 {
56594                         clear();
56595                         if(!v(ref_nested())) return false;
56596                         if(equal(ignore)) { type = 1; return true; }
56597                         else if(equal(ignore)) { type = 2; return true; }
56598                         else if(equal(ignore)) { type = 3; return true; }
56599                         else if(equal(ignore)) { type = 4; return true; }
56600                         else if(equal(ignore)) { type = 5; return true; }
56601                         else if(equal(ignore)) { type = 6; return true; }
56602                         else if(equal(ignore)) { type = 7; return true; }
56603                         else if(equal(ignore)) { type = 8; return true; }
56604                         else if(equal(ignore)) { type = 9; return true; }
56605                         else if(equal(ignore)) { type = 10; return true; }
56606                         else { type = 11; return true;}
56607                         return false;
56608
56609                 }
56610                 template<typename V> bool encode(V& v) const
56611                 {
56612                         return v(ref_nested());
56613
56614                 }
56615                 protected:
56616                 template<typename V>  bool decode(size_t index, V& v)
56617                 {
56618                         clear();
56619                         switch(index)
56620                         {
56621                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
56622                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
56623                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56624                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56625                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56626                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
56627                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
56628                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
56629                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
56630                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
56631                         case 11: type = 11; return v(ref_nested());
56632                         ref_nested().clear();
56633                         }
56634                         return false;
56635
56636                 }
56637                 template<typename V> bool encode(size_t index, V& v) const
56638                 {
56639                         if(index != type) {return false;} return v(ref_nested());
56640
56641                 }
56642                 private:
56643                 size_t type {0};
56644
56645         };
56646         struct Value_t : asn::typefield<true>
56647         {
56648                 ~Value_t()      {clear();}
56649                 size_t get_index() const {return type;}
56650                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
56651                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
56652                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
56653                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
56654                 E_RABs_Admitted_ToBeAdded_ModAckList& select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { return set<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
56655                 E_RABs_Admitted_ToBeAdded_ModAckList const* get_id_E_RABs_Admitted_ToBeAdded_ModAckList() const { return get<E_RABs_Admitted_ToBeAdded_ModAckList>(3); }
56656                 E_RABs_Admitted_ToBeModified_ModAckList& select_id_E_RABs_Admitted_ToBeModified_ModAckList() { return set<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
56657                 E_RABs_Admitted_ToBeModified_ModAckList const* get_id_E_RABs_Admitted_ToBeModified_ModAckList() const { return get<E_RABs_Admitted_ToBeModified_ModAckList>(4); }
56658                 E_RABs_Admitted_ToBeReleased_ModAckList& select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { return set<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
56659                 E_RABs_Admitted_ToBeReleased_ModAckList const* get_id_E_RABs_Admitted_ToBeReleased_ModAckList() const { return get<E_RABs_Admitted_ToBeReleased_ModAckList>(5); }
56660                 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
56661                 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
56662                 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(7); }
56663                 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(7); }
56664                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
56665                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
56666                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
56667                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
56668                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(10); }
56669                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(10); }
56670                 bool is_unknown() const { return type == 11; }
56671                 void clear()
56672                 {
56673                         switch(type)
56674                         {
56675                         case 1: var.destroy<UE_X2AP_ID>(); break;
56676                         case 2: var.destroy<UE_X2AP_ID>(); break;
56677                         case 3: var.destroy<E_RABs_Admitted_ToBeAdded_ModAckList>(); break;
56678                         case 4: var.destroy<E_RABs_Admitted_ToBeModified_ModAckList>(); break;
56679                         case 5: var.destroy<E_RABs_Admitted_ToBeReleased_ModAckList>(); break;
56680                         case 6: var.destroy<E_RAB_List>(); break;
56681                         case 7: var.destroy<SeNBtoMeNBContainer>(); break;
56682                         case 8: var.destroy<CriticalityDiagnostics>(); break;
56683                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
56684                         case 10: var.destroy<UE_X2AP_ID_Extension>(); break;
56685                         }
56686                         type = 0; ref_nested().clear();
56687                 }
56688                 template<typename V> static inline void enumerate(V& v)
56689                 {
56690                         v.template operator()<UE_X2AP_ID>(1);
56691                         v.template operator()<UE_X2AP_ID>(2);
56692                         v.template operator()<E_RABs_Admitted_ToBeAdded_ModAckList>(3);
56693                         v.template operator()<E_RABs_Admitted_ToBeModified_ModAckList>(4);
56694                         v.template operator()<E_RABs_Admitted_ToBeReleased_ModAckList>(5);
56695                         v.template operator()<E_RAB_List>(6);
56696                         v.template operator()<SeNBtoMeNBContainer>(7);
56697                         v.template operator()<CriticalityDiagnostics>(8);
56698                         v.template operator()<UE_X2AP_ID_Extension>(9);
56699                         v.template operator()<UE_X2AP_ID_Extension>(10);
56700
56701                 }
56702                 protected:
56703                 template<typename V> bool decode(size_t index, V& v)
56704                 {
56705                         clear();
56706                         switch(index)
56707                         {
56708                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
56709                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
56710                         case 3: v(select_id_E_RABs_Admitted_ToBeAdded_ModAckList()); return true;
56711                         case 4: v(select_id_E_RABs_Admitted_ToBeModified_ModAckList()); return true;
56712                         case 5: v(select_id_E_RABs_Admitted_ToBeReleased_ModAckList()); return true;
56713                         case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
56714                         case 7: v(select_id_SeNBtoMeNBContainer()); return true;
56715                         case 8: v(select_id_CriticalityDiagnostics()); return true;
56716                         case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
56717                         case 10: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
56718                         case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
56719                         }
56720                         return false;
56721
56722                 }
56723                 template<typename V> bool encode(size_t index, V& v) const
56724                 {
56725                         if(index != type) return false;
56726                         switch(type)
56727                         {
56728                         case 1: v(var.as<UE_X2AP_ID>()); return true;
56729                         case 2: v(var.as<UE_X2AP_ID>()); return true;
56730                         case 3: v(var.as<E_RABs_Admitted_ToBeAdded_ModAckList>()); return true;
56731                         case 4: v(var.as<E_RABs_Admitted_ToBeModified_ModAckList>()); return true;
56732                         case 5: v(var.as<E_RABs_Admitted_ToBeReleased_ModAckList>()); return true;
56733                         case 6: v(var.as<E_RAB_List>()); return true;
56734                         case 7: v(var.as<SeNBtoMeNBContainer>()); return true;
56735                         case 8: v(var.as<CriticalityDiagnostics>()); return true;
56736                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
56737                         case 10: v(var.as<UE_X2AP_ID_Extension>()); return true;
56738                         }
56739                         return false;
56740
56741                 }
56742                 private:
56743                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
56744                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
56745                 union union_type
56746                 {
56747                         char dummy1[sizeof(CriticalityDiagnostics)];
56748                         char dummy2[sizeof(E_RAB_List)];
56749                         char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_ModAckList)];
56750                         char dummy4[sizeof(E_RABs_Admitted_ToBeModified_ModAckList)];
56751                         char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_ModAckList)];
56752                         char dummy6[sizeof(SeNBtoMeNBContainer)];
56753                         char dummy7[sizeof(UE_X2AP_ID)];
56754                         char dummy8[sizeof(UE_X2AP_ID_Extension)];
56755
56756                 };
56757                 asn::variant<sizeof(union_type)> var;
56758                 size_t type {0};
56759
56760         };
56761         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
56762         {
56763                 size_t get_index() const {return type;}
56764                 bool is_unknown() const { return type == 11; }
56765                 void clear() {type = 0;}
56766                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
56767                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
56768                 void select_id_E_RABs_Admitted_ToBeAdded_ModAckList() { set(optional); type=3;}
56769                 void select_id_E_RABs_Admitted_ToBeModified_ModAckList() { set(optional); type=4;}
56770                 void select_id_E_RABs_Admitted_ToBeReleased_ModAckList() { set(optional); type=5;}
56771                 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
56772                 void select_id_SeNBtoMeNBContainer() { set(optional); type=7;}
56773                 void select_id_CriticalityDiagnostics() { set(optional); type=8;}
56774                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
56775                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=10;}
56776                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
56777                 template<typename V>  bool decode(V& v)
56778                 {
56779                         clear();
56780                         if(!v(ref_nested())) return false;
56781                         if(equal(mandatory)) { type = 1; return true; }
56782                         else if(equal(mandatory)) { type = 2; return true; }
56783                         else if(equal(optional)) { type = 3; return true; }
56784                         else if(equal(optional)) { type = 4; return true; }
56785                         else if(equal(optional)) { type = 5; return true; }
56786                         else if(equal(optional)) { type = 6; return true; }
56787                         else if(equal(optional)) { type = 7; return true; }
56788                         else if(equal(optional)) { type = 8; return true; }
56789                         else if(equal(optional)) { type = 9; return true; }
56790                         else if(equal(optional)) { type = 10; return true; }
56791                         else { type = 11; return true;}
56792                         return false;
56793
56794                 }
56795                 template<typename V> bool encode(V& v) const
56796                 {
56797                         return v(ref_nested());
56798
56799                 }
56800                 protected:
56801                 template<typename V>  bool decode(size_t index, V& v)
56802                 {
56803                         clear();
56804                         switch(index)
56805                         {
56806                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
56807                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
56808                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
56809                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
56810                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
56811                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
56812                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
56813                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
56814                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
56815                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
56816                         case 11: type = 11; return v(ref_nested());
56817                         ref_nested().clear();
56818                         }
56819                         return false;
56820
56821                 }
56822                 template<typename V> bool encode(size_t index, V& v) const
56823                 {
56824                         if(index != type) {return false;} return v(ref_nested());
56825
56826                 }
56827                 private:
56828                 size_t type {0};
56829
56830         };
56831
56832 };
56833 /*
56834 SeNBModificationRequestAcknowledge ::= SEQUENCE {
56835         protocolIEs             ProtocolIE-Container    {{SeNBModificationRequestAcknowledge-IEs}},
56836         ...
56837 }
56838 */
56839
56840 struct SeNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
56841 {
56842         static constexpr const char* name() {return "SeNBModificationRequestAcknowledge";}
56843         using parent_t = asn::sequence<1, 0, true, 0>;
56844         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>
56845         {
56846                 static constexpr const char* name() {return "protocolIEs_t";}
56847                 using parent_t = ProtocolIE_Container<SeNBModificationRequestAcknowledge_IEs>;
56848
56849         };
56850         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
56851         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
56852         template<typename V> void decode(V& v)
56853         {
56854                 v(protocolIEs);
56855
56856         };
56857         template<typename V> void encode(V& v) const
56858         {
56859                 v(protocolIEs);
56860
56861         };
56862         void clear()
56863         {
56864                 protocolIEs.clear();
56865
56866         };
56867         private:
56868         protocolIEs_t   protocolIEs;
56869
56870 };
56871 /*
56872 SeNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
56873         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
56874         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
56875         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
56876         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
56877         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
56878         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
56879         ...
56880 }
56881 */
56882
56883 struct SeNBModificationRequestReject_IEs
56884 {
56885         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
56886         {
56887                 size_t get_index() const {return type;}
56888                 bool is_unknown() const { return type == 7; }
56889                 void clear() {type = 0;}
56890                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
56891                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
56892                 void select_id_Cause() { set(id_Cause); type=3;}
56893                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
56894                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
56895                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
56896                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
56897                 template<typename V>  bool decode(V& v)
56898                 {
56899                         clear();
56900                         if(!v(ref_nested())) return false;
56901                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
56902                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
56903                         else if(equal(id_Cause)) { type = 3; return true; }
56904                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
56905                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
56906                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
56907                         else { type = 7; return true;}
56908                         return false;
56909
56910                 }
56911                 template<typename V> bool encode(V& v) const
56912                 {
56913                         return v(ref_nested());
56914
56915                 }
56916                 protected:
56917                 template<typename V>  bool decode(size_t index, V& v)
56918                 {
56919                         clear();
56920                         switch(index)
56921                         {
56922                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
56923                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
56924                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
56925                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
56926                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
56927                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
56928                         case 7: type = 7; return v(ref_nested());
56929                         ref_nested().clear();
56930                         }
56931                         return false;
56932
56933                 }
56934                 template<typename V> bool encode(size_t index, V& v) const
56935                 {
56936                         if(index != type) {return false;} return v(ref_nested());
56937
56938                 }
56939                 private:
56940                 size_t type {0};
56941
56942         };
56943         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
56944         {
56945                 size_t get_index() const {return type;}
56946                 bool is_unknown() const { return type == 7; }
56947                 void clear() {type = 0;}
56948                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
56949                 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
56950                 void select_id_Cause() { set(ignore); type=3;}
56951                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
56952                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
56953                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
56954                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
56955                 template<typename V>  bool decode(V& v)
56956                 {
56957                         clear();
56958                         if(!v(ref_nested())) return false;
56959                         if(equal(ignore)) { type = 1; return true; }
56960                         else if(equal(ignore)) { type = 2; return true; }
56961                         else if(equal(ignore)) { type = 3; return true; }
56962                         else if(equal(ignore)) { type = 4; return true; }
56963                         else if(equal(ignore)) { type = 5; return true; }
56964                         else if(equal(ignore)) { type = 6; return true; }
56965                         else { type = 7; return true;}
56966                         return false;
56967
56968                 }
56969                 template<typename V> bool encode(V& v) const
56970                 {
56971                         return v(ref_nested());
56972
56973                 }
56974                 protected:
56975                 template<typename V>  bool decode(size_t index, V& v)
56976                 {
56977                         clear();
56978                         switch(index)
56979                         {
56980                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
56981                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
56982                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
56983                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
56984                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
56985                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
56986                         case 7: type = 7; return v(ref_nested());
56987                         ref_nested().clear();
56988                         }
56989                         return false;
56990
56991                 }
56992                 template<typename V> bool encode(size_t index, V& v) const
56993                 {
56994                         if(index != type) {return false;} return v(ref_nested());
56995
56996                 }
56997                 private:
56998                 size_t type {0};
56999
57000         };
57001         struct Value_t : asn::typefield<true>
57002         {
57003                 ~Value_t()      {clear();}
57004                 size_t get_index() const {return type;}
57005                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57006                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57007                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57008                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57009                 Cause& select_id_Cause() { return set<Cause>(3); }
57010                 Cause const* get_id_Cause() const { return get<Cause>(3); }
57011                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
57012                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
57013                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57014                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57015                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
57016                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
57017                 bool is_unknown() const { return type == 7; }
57018                 void clear()
57019                 {
57020                         switch(type)
57021                         {
57022                         case 1: var.destroy<UE_X2AP_ID>(); break;
57023                         case 2: var.destroy<UE_X2AP_ID>(); break;
57024                         case 3: var.destroy<Cause>(); break;
57025                         case 4: var.destroy<CriticalityDiagnostics>(); break;
57026                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57027                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
57028                         }
57029                         type = 0; ref_nested().clear();
57030                 }
57031                 template<typename V> static inline void enumerate(V& v)
57032                 {
57033                         v.template operator()<UE_X2AP_ID>(1);
57034                         v.template operator()<UE_X2AP_ID>(2);
57035                         v.template operator()<Cause>(3);
57036                         v.template operator()<CriticalityDiagnostics>(4);
57037                         v.template operator()<UE_X2AP_ID_Extension>(5);
57038                         v.template operator()<UE_X2AP_ID_Extension>(6);
57039
57040                 }
57041                 protected:
57042                 template<typename V> bool decode(size_t index, V& v)
57043                 {
57044                         clear();
57045                         switch(index)
57046                         {
57047                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57048                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57049                         case 3: v(select_id_Cause()); return true;
57050                         case 4: v(select_id_CriticalityDiagnostics()); return true;
57051                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57052                         case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57053                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
57054                         }
57055                         return false;
57056
57057                 }
57058                 template<typename V> bool encode(size_t index, V& v) const
57059                 {
57060                         if(index != type) return false;
57061                         switch(type)
57062                         {
57063                         case 1: v(var.as<UE_X2AP_ID>()); return true;
57064                         case 2: v(var.as<UE_X2AP_ID>()); return true;
57065                         case 3: v(var.as<Cause>()); return true;
57066                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
57067                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
57068                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
57069                         }
57070                         return false;
57071
57072                 }
57073                 private:
57074                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57075                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57076                 union union_type
57077                 {
57078                         char dummy1[sizeof(Cause)];
57079                         char dummy2[sizeof(CriticalityDiagnostics)];
57080                         char dummy3[sizeof(UE_X2AP_ID)];
57081                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
57082
57083                 };
57084                 asn::variant<sizeof(union_type)> var;
57085                 size_t type {0};
57086
57087         };
57088         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57089         {
57090                 size_t get_index() const {return type;}
57091                 bool is_unknown() const { return type == 7; }
57092                 void clear() {type = 0;}
57093                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57094                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57095                 void select_id_Cause() { set(mandatory); type=3;}
57096                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
57097                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
57098                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
57099                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57100                 template<typename V>  bool decode(V& v)
57101                 {
57102                         clear();
57103                         if(!v(ref_nested())) return false;
57104                         if(equal(mandatory)) { type = 1; return true; }
57105                         else if(equal(mandatory)) { type = 2; return true; }
57106                         else if(equal(mandatory)) { type = 3; return true; }
57107                         else if(equal(optional)) { type = 4; return true; }
57108                         else if(equal(optional)) { type = 5; return true; }
57109                         else if(equal(optional)) { type = 6; return true; }
57110                         else { type = 7; return true;}
57111                         return false;
57112
57113                 }
57114                 template<typename V> bool encode(V& v) const
57115                 {
57116                         return v(ref_nested());
57117
57118                 }
57119                 protected:
57120                 template<typename V>  bool decode(size_t index, V& v)
57121                 {
57122                         clear();
57123                         switch(index)
57124                         {
57125                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57126                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57127                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57128                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57129                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57130                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
57131                         case 7: type = 7; return v(ref_nested());
57132                         ref_nested().clear();
57133                         }
57134                         return false;
57135
57136                 }
57137                 template<typename V> bool encode(size_t index, V& v) const
57138                 {
57139                         if(index != type) {return false;} return v(ref_nested());
57140
57141                 }
57142                 private:
57143                 size_t type {0};
57144
57145         };
57146
57147 };
57148 /*
57149 SeNBModificationRequestReject ::= SEQUENCE {
57150         protocolIEs             ProtocolIE-Container    {{SeNBModificationRequestReject-IEs}},
57151         ...
57152 }
57153 */
57154
57155 struct SeNBModificationRequestReject : asn::sequence<1, 0, true, 0>
57156 {
57157         static constexpr const char* name() {return "SeNBModificationRequestReject";}
57158         using parent_t = asn::sequence<1, 0, true, 0>;
57159         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequestReject_IEs>
57160         {
57161                 static constexpr const char* name() {return "protocolIEs_t";}
57162                 using parent_t = ProtocolIE_Container<SeNBModificationRequestReject_IEs>;
57163
57164         };
57165         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57166         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57167         template<typename V> void decode(V& v)
57168         {
57169                 v(protocolIEs);
57170
57171         };
57172         template<typename V> void encode(V& v) const
57173         {
57174                 v(protocolIEs);
57175
57176         };
57177         void clear()
57178         {
57179                 protocolIEs.clear();
57180
57181         };
57182         private:
57183         protocolIEs_t   protocolIEs;
57184
57185 };
57186 /*
57187 SeNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
57188         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
57189         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                 PRESENCE mandatory}|
57190         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                                              PRESENCE mandatory}|
57191         { ID id-SCGChangeIndication                                     CRITICALITY ignore      TYPE SCGChangeIndication                                PRESENCE optional}|
57192         { ID id-E-RABs-ToBeReleased-ModReqd                     CRITICALITY ignore      TYPE E-RABs-ToBeReleased-ModReqd                PRESENCE optional}|
57193         { ID id-SeNBtoMeNBContainer                                     CRITICALITY ignore      TYPE SeNBtoMeNBContainer                                PRESENCE optional}|
57194         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional}|
57195         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                               PRESENCE optional},
57196         ...
57197 }
57198 */
57199
57200 struct SeNBModificationRequired_IEs
57201 {
57202         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57203         {
57204                 size_t get_index() const {return type;}
57205                 bool is_unknown() const { return type == 9; }
57206                 void clear() {type = 0;}
57207                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57208                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57209                 void select_id_Cause() { set(id_Cause); type=3;}
57210                 void select_id_SCGChangeIndication() { set(id_SCGChangeIndication); type=4;}
57211                 void select_id_E_RABs_ToBeReleased_ModReqd() { set(id_E_RABs_ToBeReleased_ModReqd); type=5;}
57212                 void select_id_SeNBtoMeNBContainer() { set(id_SeNBtoMeNBContainer); type=6;}
57213                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
57214                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=8;}
57215                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57216                 template<typename V>  bool decode(V& v)
57217                 {
57218                         clear();
57219                         if(!v(ref_nested())) return false;
57220                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57221                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57222                         else if(equal(id_Cause)) { type = 3; return true; }
57223                         else if(equal(id_SCGChangeIndication)) { type = 4; return true; }
57224                         else if(equal(id_E_RABs_ToBeReleased_ModReqd)) { type = 5; return true; }
57225                         else if(equal(id_SeNBtoMeNBContainer)) { type = 6; return true; }
57226                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
57227                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 8; return true; }
57228                         else { type = 9; return true;}
57229                         return false;
57230
57231                 }
57232                 template<typename V> bool encode(V& v) const
57233                 {
57234                         return v(ref_nested());
57235
57236                 }
57237                 protected:
57238                 template<typename V>  bool decode(size_t index, V& v)
57239                 {
57240                         clear();
57241                         switch(index)
57242                         {
57243                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57244                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57245                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
57246                         case 4: type = 4; if(v(ref_nested())) { return equal(id_SCGChangeIndication);} return false;
57247                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_ModReqd);} return false;
57248                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNBtoMeNBContainer);} return false;
57249                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57250                         case 8: type = 8; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57251                         case 9: type = 9; return v(ref_nested());
57252                         ref_nested().clear();
57253                         }
57254                         return false;
57255
57256                 }
57257                 template<typename V> bool encode(size_t index, V& v) const
57258                 {
57259                         if(index != type) {return false;} return v(ref_nested());
57260
57261                 }
57262                 private:
57263                 size_t type {0};
57264
57265         };
57266         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57267         {
57268                 size_t get_index() const {return type;}
57269                 bool is_unknown() const { return type == 9; }
57270                 void clear() {type = 0;}
57271                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
57272                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
57273                 void select_id_Cause() { set(ignore); type=3;}
57274                 void select_id_SCGChangeIndication() { set(ignore); type=4;}
57275                 void select_id_E_RABs_ToBeReleased_ModReqd() { set(ignore); type=5;}
57276                 void select_id_SeNBtoMeNBContainer() { set(ignore); type=6;}
57277                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
57278                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=8;}
57279                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57280                 template<typename V>  bool decode(V& v)
57281                 {
57282                         clear();
57283                         if(!v(ref_nested())) return false;
57284                         if(equal(reject)) { type = 1; return true; }
57285                         else if(equal(reject)) { type = 2; return true; }
57286                         else if(equal(ignore)) { type = 3; return true; }
57287                         else if(equal(ignore)) { type = 4; return true; }
57288                         else if(equal(ignore)) { type = 5; return true; }
57289                         else if(equal(ignore)) { type = 6; return true; }
57290                         else if(equal(reject)) { type = 7; return true; }
57291                         else if(equal(reject)) { type = 8; return true; }
57292                         else { type = 9; return true;}
57293                         return false;
57294
57295                 }
57296                 template<typename V> bool encode(V& v) const
57297                 {
57298                         return v(ref_nested());
57299
57300                 }
57301                 protected:
57302                 template<typename V>  bool decode(size_t index, V& v)
57303                 {
57304                         clear();
57305                         switch(index)
57306                         {
57307                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
57308                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
57309                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57310                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
57311                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
57312                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
57313                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
57314                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
57315                         case 9: type = 9; return v(ref_nested());
57316                         ref_nested().clear();
57317                         }
57318                         return false;
57319
57320                 }
57321                 template<typename V> bool encode(size_t index, V& v) const
57322                 {
57323                         if(index != type) {return false;} return v(ref_nested());
57324
57325                 }
57326                 private:
57327                 size_t type {0};
57328
57329         };
57330         struct Value_t : asn::typefield<true>
57331         {
57332                 ~Value_t()      {clear();}
57333                 size_t get_index() const {return type;}
57334                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57335                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57336                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57337                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57338                 Cause& select_id_Cause() { return set<Cause>(3); }
57339                 Cause const* get_id_Cause() const { return get<Cause>(3); }
57340                 SCGChangeIndication& select_id_SCGChangeIndication() { return set<SCGChangeIndication>(4); }
57341                 SCGChangeIndication const* get_id_SCGChangeIndication() const { return get<SCGChangeIndication>(4); }
57342                 E_RABs_ToBeReleased_ModReqd& select_id_E_RABs_ToBeReleased_ModReqd() { return set<E_RABs_ToBeReleased_ModReqd>(5); }
57343                 E_RABs_ToBeReleased_ModReqd const* get_id_E_RABs_ToBeReleased_ModReqd() const { return get<E_RABs_ToBeReleased_ModReqd>(5); }
57344                 SeNBtoMeNBContainer& select_id_SeNBtoMeNBContainer() { return set<SeNBtoMeNBContainer>(6); }
57345                 SeNBtoMeNBContainer const* get_id_SeNBtoMeNBContainer() const { return get<SeNBtoMeNBContainer>(6); }
57346                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
57347                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
57348                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(8); }
57349                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(8); }
57350                 bool is_unknown() const { return type == 9; }
57351                 void clear()
57352                 {
57353                         switch(type)
57354                         {
57355                         case 1: var.destroy<UE_X2AP_ID>(); break;
57356                         case 2: var.destroy<UE_X2AP_ID>(); break;
57357                         case 3: var.destroy<Cause>(); break;
57358                         case 4: var.destroy<SCGChangeIndication>(); break;
57359                         case 5: var.destroy<E_RABs_ToBeReleased_ModReqd>(); break;
57360                         case 6: var.destroy<SeNBtoMeNBContainer>(); break;
57361                         case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
57362                         case 8: var.destroy<UE_X2AP_ID_Extension>(); break;
57363                         }
57364                         type = 0; ref_nested().clear();
57365                 }
57366                 template<typename V> static inline void enumerate(V& v)
57367                 {
57368                         v.template operator()<UE_X2AP_ID>(1);
57369                         v.template operator()<UE_X2AP_ID>(2);
57370                         v.template operator()<Cause>(3);
57371                         v.template operator()<SCGChangeIndication>(4);
57372                         v.template operator()<E_RABs_ToBeReleased_ModReqd>(5);
57373                         v.template operator()<SeNBtoMeNBContainer>(6);
57374                         v.template operator()<UE_X2AP_ID_Extension>(7);
57375                         v.template operator()<UE_X2AP_ID_Extension>(8);
57376
57377                 }
57378                 protected:
57379                 template<typename V> bool decode(size_t index, V& v)
57380                 {
57381                         clear();
57382                         switch(index)
57383                         {
57384                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57385                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57386                         case 3: v(select_id_Cause()); return true;
57387                         case 4: v(select_id_SCGChangeIndication()); return true;
57388                         case 5: v(select_id_E_RABs_ToBeReleased_ModReqd()); return true;
57389                         case 6: v(select_id_SeNBtoMeNBContainer()); return true;
57390                         case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57391                         case 8: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57392                         case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
57393                         }
57394                         return false;
57395
57396                 }
57397                 template<typename V> bool encode(size_t index, V& v) const
57398                 {
57399                         if(index != type) return false;
57400                         switch(type)
57401                         {
57402                         case 1: v(var.as<UE_X2AP_ID>()); return true;
57403                         case 2: v(var.as<UE_X2AP_ID>()); return true;
57404                         case 3: v(var.as<Cause>()); return true;
57405                         case 4: v(var.as<SCGChangeIndication>()); return true;
57406                         case 5: v(var.as<E_RABs_ToBeReleased_ModReqd>()); return true;
57407                         case 6: v(var.as<SeNBtoMeNBContainer>()); return true;
57408                         case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
57409                         case 8: v(var.as<UE_X2AP_ID_Extension>()); return true;
57410                         }
57411                         return false;
57412
57413                 }
57414                 private:
57415                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57416                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57417                 union union_type
57418                 {
57419                         char dummy1[sizeof(Cause)];
57420                         char dummy2[sizeof(E_RABs_ToBeReleased_ModReqd)];
57421                         char dummy3[sizeof(SCGChangeIndication)];
57422                         char dummy4[sizeof(SeNBtoMeNBContainer)];
57423                         char dummy5[sizeof(UE_X2AP_ID)];
57424                         char dummy6[sizeof(UE_X2AP_ID_Extension)];
57425
57426                 };
57427                 asn::variant<sizeof(union_type)> var;
57428                 size_t type {0};
57429
57430         };
57431         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57432         {
57433                 size_t get_index() const {return type;}
57434                 bool is_unknown() const { return type == 9; }
57435                 void clear() {type = 0;}
57436                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57437                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57438                 void select_id_Cause() { set(mandatory); type=3;}
57439                 void select_id_SCGChangeIndication() { set(optional); type=4;}
57440                 void select_id_E_RABs_ToBeReleased_ModReqd() { set(optional); type=5;}
57441                 void select_id_SeNBtoMeNBContainer() { set(optional); type=6;}
57442                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
57443                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=8;}
57444                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57445                 template<typename V>  bool decode(V& v)
57446                 {
57447                         clear();
57448                         if(!v(ref_nested())) return false;
57449                         if(equal(mandatory)) { type = 1; return true; }
57450                         else if(equal(mandatory)) { type = 2; return true; }
57451                         else if(equal(mandatory)) { type = 3; return true; }
57452                         else if(equal(optional)) { type = 4; return true; }
57453                         else if(equal(optional)) { type = 5; return true; }
57454                         else if(equal(optional)) { type = 6; return true; }
57455                         else if(equal(optional)) { type = 7; return true; }
57456                         else if(equal(optional)) { type = 8; return true; }
57457                         else { type = 9; return true;}
57458                         return false;
57459
57460                 }
57461                 template<typename V> bool encode(V& v) const
57462                 {
57463                         return v(ref_nested());
57464
57465                 }
57466                 protected:
57467                 template<typename V>  bool decode(size_t index, V& v)
57468                 {
57469                         clear();
57470                         switch(index)
57471                         {
57472                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57473                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57474                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57475                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57476                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57477                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
57478                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
57479                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
57480                         case 9: type = 9; return v(ref_nested());
57481                         ref_nested().clear();
57482                         }
57483                         return false;
57484
57485                 }
57486                 template<typename V> bool encode(size_t index, V& v) const
57487                 {
57488                         if(index != type) {return false;} return v(ref_nested());
57489
57490                 }
57491                 private:
57492                 size_t type {0};
57493
57494         };
57495
57496 };
57497 /*
57498 SeNBModificationRequired ::= SEQUENCE {
57499         protocolIEs             ProtocolIE-Container            {{SeNBModificationRequired-IEs}},
57500         ...
57501 }
57502 */
57503
57504 struct SeNBModificationRequired : asn::sequence<1, 0, true, 0>
57505 {
57506         static constexpr const char* name() {return "SeNBModificationRequired";}
57507         using parent_t = asn::sequence<1, 0, true, 0>;
57508         struct protocolIEs_t : ProtocolIE_Container<SeNBModificationRequired_IEs>
57509         {
57510                 static constexpr const char* name() {return "protocolIEs_t";}
57511                 using parent_t = ProtocolIE_Container<SeNBModificationRequired_IEs>;
57512
57513         };
57514         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57515         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57516         template<typename V> void decode(V& v)
57517         {
57518                 v(protocolIEs);
57519
57520         };
57521         template<typename V> void encode(V& v) const
57522         {
57523                 v(protocolIEs);
57524
57525         };
57526         void clear()
57527         {
57528                 protocolIEs.clear();
57529
57530         };
57531         private:
57532         protocolIEs_t   protocolIEs;
57533
57534 };
57535 /*
57536 SeNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
57537         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
57538         { ID id-SeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
57539         { ID id-ResponseInformationSeNBReconfComp               CRITICALITY ignore      TYPE ResponseInformationSeNBReconfComp  PRESENCE mandatory}|
57540         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
57541         { ID id-SeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional},
57542         ...
57543 }
57544 */
57545
57546 struct SeNBReconfigurationComplete_IEs
57547 {
57548         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57549         {
57550                 size_t get_index() const {return type;}
57551                 bool is_unknown() const { return type == 6; }
57552                 void clear() {type = 0;}
57553                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57554                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57555                 void select_id_ResponseInformationSeNBReconfComp() { set(id_ResponseInformationSeNBReconfComp); type=3;}
57556                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
57557                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
57558                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57559                 template<typename V>  bool decode(V& v)
57560                 {
57561                         clear();
57562                         if(!v(ref_nested())) return false;
57563                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57564                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57565                         else if(equal(id_ResponseInformationSeNBReconfComp)) { type = 3; return true; }
57566                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
57567                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
57568                         else { type = 6; return true;}
57569                         return false;
57570
57571                 }
57572                 template<typename V> bool encode(V& v) const
57573                 {
57574                         return v(ref_nested());
57575
57576                 }
57577                 protected:
57578                 template<typename V>  bool decode(size_t index, V& v)
57579                 {
57580                         clear();
57581                         switch(index)
57582                         {
57583                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57584                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57585                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSeNBReconfComp);} return false;
57586                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57587                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57588                         case 6: type = 6; return v(ref_nested());
57589                         ref_nested().clear();
57590                         }
57591                         return false;
57592
57593                 }
57594                 template<typename V> bool encode(size_t index, V& v) const
57595                 {
57596                         if(index != type) {return false;} return v(ref_nested());
57597
57598                 }
57599                 private:
57600                 size_t type {0};
57601
57602         };
57603         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57604         {
57605                 size_t get_index() const {return type;}
57606                 bool is_unknown() const { return type == 6; }
57607                 void clear() {type = 0;}
57608                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
57609                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
57610                 void select_id_ResponseInformationSeNBReconfComp() { set(ignore); type=3;}
57611                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
57612                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
57613                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57614                 template<typename V>  bool decode(V& v)
57615                 {
57616                         clear();
57617                         if(!v(ref_nested())) return false;
57618                         if(equal(reject)) { type = 1; return true; }
57619                         else if(equal(reject)) { type = 2; return true; }
57620                         else if(equal(ignore)) { type = 3; return true; }
57621                         else if(equal(reject)) { type = 4; return true; }
57622                         else if(equal(reject)) { type = 5; return true; }
57623                         else { type = 6; return true;}
57624                         return false;
57625
57626                 }
57627                 template<typename V> bool encode(V& v) const
57628                 {
57629                         return v(ref_nested());
57630
57631                 }
57632                 protected:
57633                 template<typename V>  bool decode(size_t index, V& v)
57634                 {
57635                         clear();
57636                         switch(index)
57637                         {
57638                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
57639                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
57640                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57641                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
57642                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
57643                         case 6: type = 6; return v(ref_nested());
57644                         ref_nested().clear();
57645                         }
57646                         return false;
57647
57648                 }
57649                 template<typename V> bool encode(size_t index, V& v) const
57650                 {
57651                         if(index != type) {return false;} return v(ref_nested());
57652
57653                 }
57654                 private:
57655                 size_t type {0};
57656
57657         };
57658         struct Value_t : asn::typefield<true>
57659         {
57660                 ~Value_t()      {clear();}
57661                 size_t get_index() const {return type;}
57662                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57663                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57664                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57665                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57666                 ResponseInformationSeNBReconfComp& select_id_ResponseInformationSeNBReconfComp() { return set<ResponseInformationSeNBReconfComp>(3); }
57667                 ResponseInformationSeNBReconfComp const* get_id_ResponseInformationSeNBReconfComp() const { return get<ResponseInformationSeNBReconfComp>(3); }
57668                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
57669                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
57670                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57671                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57672                 bool is_unknown() const { return type == 6; }
57673                 void clear()
57674                 {
57675                         switch(type)
57676                         {
57677                         case 1: var.destroy<UE_X2AP_ID>(); break;
57678                         case 2: var.destroy<UE_X2AP_ID>(); break;
57679                         case 3: var.destroy<ResponseInformationSeNBReconfComp>(); break;
57680                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
57681                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57682                         }
57683                         type = 0; ref_nested().clear();
57684                 }
57685                 template<typename V> static inline void enumerate(V& v)
57686                 {
57687                         v.template operator()<UE_X2AP_ID>(1);
57688                         v.template operator()<UE_X2AP_ID>(2);
57689                         v.template operator()<ResponseInformationSeNBReconfComp>(3);
57690                         v.template operator()<UE_X2AP_ID_Extension>(4);
57691                         v.template operator()<UE_X2AP_ID_Extension>(5);
57692
57693                 }
57694                 protected:
57695                 template<typename V> bool decode(size_t index, V& v)
57696                 {
57697                         clear();
57698                         switch(index)
57699                         {
57700                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
57701                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
57702                         case 3: v(select_id_ResponseInformationSeNBReconfComp()); return true;
57703                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
57704                         case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
57705                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
57706                         }
57707                         return false;
57708
57709                 }
57710                 template<typename V> bool encode(size_t index, V& v) const
57711                 {
57712                         if(index != type) return false;
57713                         switch(type)
57714                         {
57715                         case 1: v(var.as<UE_X2AP_ID>()); return true;
57716                         case 2: v(var.as<UE_X2AP_ID>()); return true;
57717                         case 3: v(var.as<ResponseInformationSeNBReconfComp>()); return true;
57718                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
57719                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
57720                         }
57721                         return false;
57722
57723                 }
57724                 private:
57725                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
57726                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
57727                 union union_type
57728                 {
57729                         char dummy1[sizeof(ResponseInformationSeNBReconfComp)];
57730                         char dummy2[sizeof(UE_X2AP_ID)];
57731                         char dummy3[sizeof(UE_X2AP_ID_Extension)];
57732
57733                 };
57734                 asn::variant<sizeof(union_type)> var;
57735                 size_t type {0};
57736
57737         };
57738         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
57739         {
57740                 size_t get_index() const {return type;}
57741                 bool is_unknown() const { return type == 6; }
57742                 void clear() {type = 0;}
57743                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
57744                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
57745                 void select_id_ResponseInformationSeNBReconfComp() { set(mandatory); type=3;}
57746                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
57747                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
57748                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
57749                 template<typename V>  bool decode(V& v)
57750                 {
57751                         clear();
57752                         if(!v(ref_nested())) return false;
57753                         if(equal(mandatory)) { type = 1; return true; }
57754                         else if(equal(mandatory)) { type = 2; return true; }
57755                         else if(equal(mandatory)) { type = 3; return true; }
57756                         else if(equal(optional)) { type = 4; return true; }
57757                         else if(equal(optional)) { type = 5; return true; }
57758                         else { type = 6; return true;}
57759                         return false;
57760
57761                 }
57762                 template<typename V> bool encode(V& v) const
57763                 {
57764                         return v(ref_nested());
57765
57766                 }
57767                 protected:
57768                 template<typename V>  bool decode(size_t index, V& v)
57769                 {
57770                         clear();
57771                         switch(index)
57772                         {
57773                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
57774                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
57775                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
57776                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
57777                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
57778                         case 6: type = 6; return v(ref_nested());
57779                         ref_nested().clear();
57780                         }
57781                         return false;
57782
57783                 }
57784                 template<typename V> bool encode(size_t index, V& v) const
57785                 {
57786                         if(index != type) {return false;} return v(ref_nested());
57787
57788                 }
57789                 private:
57790                 size_t type {0};
57791
57792         };
57793
57794 };
57795 /*
57796 SeNBReconfigurationComplete ::= SEQUENCE {
57797         protocolIEs             ProtocolIE-Container    {{SeNBReconfigurationComplete-IEs}},
57798         ...
57799 }
57800 */
57801
57802 struct SeNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
57803 {
57804         static constexpr const char* name() {return "SeNBReconfigurationComplete";}
57805         using parent_t = asn::sequence<1, 0, true, 0>;
57806         struct protocolIEs_t : ProtocolIE_Container<SeNBReconfigurationComplete_IEs>
57807         {
57808                 static constexpr const char* name() {return "protocolIEs_t";}
57809                 using parent_t = ProtocolIE_Container<SeNBReconfigurationComplete_IEs>;
57810
57811         };
57812         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
57813         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
57814         template<typename V> void decode(V& v)
57815         {
57816                 v(protocolIEs);
57817
57818         };
57819         template<typename V> void encode(V& v) const
57820         {
57821                 v(protocolIEs);
57822
57823         };
57824         void clear()
57825         {
57826                 protocolIEs.clear();
57827
57828         };
57829         private:
57830         protocolIEs_t   protocolIEs;
57831
57832 };
57833 /*
57834 SeNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
57835         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
57836         { ID id-SeNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
57837         { ID id-E-RABs-ToBeReleased-List-RelConf                CRITICALITY ignore      TYPE E-RABs-ToBeReleased-List-RelConf           PRESENCE optional}|
57838         { ID id-CriticalityDiagnostics                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                     PRESENCE optional}|
57839         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
57840         { ID id-SeNB-UE-X2AP-ID-Extension                               CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional},
57841         ...
57842 }
57843 */
57844
57845 struct SeNBReleaseConfirm_IEs
57846 {
57847         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
57848         {
57849                 size_t get_index() const {return type;}
57850                 bool is_unknown() const { return type == 7; }
57851                 void clear() {type = 0;}
57852                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
57853                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
57854                 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(id_E_RABs_ToBeReleased_List_RelConf); type=3;}
57855                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
57856                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
57857                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=6;}
57858                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
57859                 template<typename V>  bool decode(V& v)
57860                 {
57861                         clear();
57862                         if(!v(ref_nested())) return false;
57863                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
57864                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
57865                         else if(equal(id_E_RABs_ToBeReleased_List_RelConf)) { type = 3; return true; }
57866                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
57867                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
57868                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
57869                         else { type = 7; return true;}
57870                         return false;
57871
57872                 }
57873                 template<typename V> bool encode(V& v) const
57874                 {
57875                         return v(ref_nested());
57876
57877                 }
57878                 protected:
57879                 template<typename V>  bool decode(size_t index, V& v)
57880                 {
57881                         clear();
57882                         switch(index)
57883                         {
57884                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
57885                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
57886                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelConf);} return false;
57887                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
57888                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
57889                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
57890                         case 7: type = 7; return v(ref_nested());
57891                         ref_nested().clear();
57892                         }
57893                         return false;
57894
57895                 }
57896                 template<typename V> bool encode(size_t index, V& v) const
57897                 {
57898                         if(index != type) {return false;} return v(ref_nested());
57899
57900                 }
57901                 private:
57902                 size_t type {0};
57903
57904         };
57905         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
57906         {
57907                 size_t get_index() const {return type;}
57908                 bool is_unknown() const { return type == 7; }
57909                 void clear() {type = 0;}
57910                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
57911                 void select_id_SeNB_UE_X2AP_ID() { set(ignore); type=2;}
57912                 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(ignore); type=3;}
57913                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
57914                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
57915                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
57916                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
57917                 template<typename V>  bool decode(V& v)
57918                 {
57919                         clear();
57920                         if(!v(ref_nested())) return false;
57921                         if(equal(ignore)) { type = 1; return true; }
57922                         else if(equal(ignore)) { type = 2; return true; }
57923                         else if(equal(ignore)) { type = 3; return true; }
57924                         else if(equal(ignore)) { type = 4; return true; }
57925                         else if(equal(ignore)) { type = 5; return true; }
57926                         else if(equal(ignore)) { type = 6; return true; }
57927                         else { type = 7; return true;}
57928                         return false;
57929
57930                 }
57931                 template<typename V> bool encode(V& v) const
57932                 {
57933                         return v(ref_nested());
57934
57935                 }
57936                 protected:
57937                 template<typename V>  bool decode(size_t index, V& v)
57938                 {
57939                         clear();
57940                         switch(index)
57941                         {
57942                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
57943                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
57944                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
57945                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
57946                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
57947                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
57948                         case 7: type = 7; return v(ref_nested());
57949                         ref_nested().clear();
57950                         }
57951                         return false;
57952
57953                 }
57954                 template<typename V> bool encode(size_t index, V& v) const
57955                 {
57956                         if(index != type) {return false;} return v(ref_nested());
57957
57958                 }
57959                 private:
57960                 size_t type {0};
57961
57962         };
57963         struct Value_t : asn::typefield<true>
57964         {
57965                 ~Value_t()      {clear();}
57966                 size_t get_index() const {return type;}
57967                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
57968                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
57969                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
57970                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
57971                 E_RABs_ToBeReleased_List_RelConf& select_id_E_RABs_ToBeReleased_List_RelConf() { return set<E_RABs_ToBeReleased_List_RelConf>(3); }
57972                 E_RABs_ToBeReleased_List_RelConf const* get_id_E_RABs_ToBeReleased_List_RelConf() const { return get<E_RABs_ToBeReleased_List_RelConf>(3); }
57973                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
57974                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
57975                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
57976                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
57977                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
57978                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
57979                 bool is_unknown() const { return type == 7; }
57980                 void clear()
57981                 {
57982                         switch(type)
57983                         {
57984                         case 1: var.destroy<UE_X2AP_ID>(); break;
57985                         case 2: var.destroy<UE_X2AP_ID>(); break;
57986                         case 3: var.destroy<E_RABs_ToBeReleased_List_RelConf>(); break;
57987                         case 4: var.destroy<CriticalityDiagnostics>(); break;
57988                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
57989                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
57990                         }
57991                         type = 0; ref_nested().clear();
57992                 }
57993                 template<typename V> static inline void enumerate(V& v)
57994                 {
57995                         v.template operator()<UE_X2AP_ID>(1);
57996                         v.template operator()<UE_X2AP_ID>(2);
57997                         v.template operator()<E_RABs_ToBeReleased_List_RelConf>(3);
57998                         v.template operator()<CriticalityDiagnostics>(4);
57999                         v.template operator()<UE_X2AP_ID_Extension>(5);
58000                         v.template operator()<UE_X2AP_ID_Extension>(6);
58001
58002                 }
58003                 protected:
58004                 template<typename V> bool decode(size_t index, V& v)
58005                 {
58006                         clear();
58007                         switch(index)
58008                         {
58009                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58010                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58011                         case 3: v(select_id_E_RABs_ToBeReleased_List_RelConf()); return true;
58012                         case 4: v(select_id_CriticalityDiagnostics()); return true;
58013                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58014                         case 6: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58015                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
58016                         }
58017                         return false;
58018
58019                 }
58020                 template<typename V> bool encode(size_t index, V& v) const
58021                 {
58022                         if(index != type) return false;
58023                         switch(type)
58024                         {
58025                         case 1: v(var.as<UE_X2AP_ID>()); return true;
58026                         case 2: v(var.as<UE_X2AP_ID>()); return true;
58027                         case 3: v(var.as<E_RABs_ToBeReleased_List_RelConf>()); return true;
58028                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
58029                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
58030                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
58031                         }
58032                         return false;
58033
58034                 }
58035                 private:
58036                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58037                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58038                 union union_type
58039                 {
58040                         char dummy1[sizeof(CriticalityDiagnostics)];
58041                         char dummy2[sizeof(E_RABs_ToBeReleased_List_RelConf)];
58042                         char dummy3[sizeof(UE_X2AP_ID)];
58043                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
58044
58045                 };
58046                 asn::variant<sizeof(union_type)> var;
58047                 size_t type {0};
58048
58049         };
58050         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58051         {
58052                 size_t get_index() const {return type;}
58053                 bool is_unknown() const { return type == 7; }
58054                 void clear() {type = 0;}
58055                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58056                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
58057                 void select_id_E_RABs_ToBeReleased_List_RelConf() { set(optional); type=3;}
58058                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
58059                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
58060                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
58061                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58062                 template<typename V>  bool decode(V& v)
58063                 {
58064                         clear();
58065                         if(!v(ref_nested())) return false;
58066                         if(equal(mandatory)) { type = 1; return true; }
58067                         else if(equal(mandatory)) { type = 2; return true; }
58068                         else if(equal(optional)) { type = 3; return true; }
58069                         else if(equal(optional)) { type = 4; return true; }
58070                         else if(equal(optional)) { type = 5; return true; }
58071                         else if(equal(optional)) { type = 6; return true; }
58072                         else { type = 7; return true;}
58073                         return false;
58074
58075                 }
58076                 template<typename V> bool encode(V& v) const
58077                 {
58078                         return v(ref_nested());
58079
58080                 }
58081                 protected:
58082                 template<typename V>  bool decode(size_t index, V& v)
58083                 {
58084                         clear();
58085                         switch(index)
58086                         {
58087                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58088                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
58089                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
58090                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58091                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58092                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
58093                         case 7: type = 7; return v(ref_nested());
58094                         ref_nested().clear();
58095                         }
58096                         return false;
58097
58098                 }
58099                 template<typename V> bool encode(size_t index, V& v) const
58100                 {
58101                         if(index != type) {return false;} return v(ref_nested());
58102
58103                 }
58104                 private:
58105                 size_t type {0};
58106
58107         };
58108
58109 };
58110 /*
58111 SeNBReleaseConfirm ::= SEQUENCE {
58112         protocolIEs             ProtocolIE-Container    {{SeNBReleaseConfirm-IEs}},
58113         ...
58114 }
58115 */
58116
58117 struct SeNBReleaseConfirm : asn::sequence<1, 0, true, 0>
58118 {
58119         static constexpr const char* name() {return "SeNBReleaseConfirm";}
58120         using parent_t = asn::sequence<1, 0, true, 0>;
58121         struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseConfirm_IEs>
58122         {
58123                 static constexpr const char* name() {return "protocolIEs_t";}
58124                 using parent_t = ProtocolIE_Container<SeNBReleaseConfirm_IEs>;
58125
58126         };
58127         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58128         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58129         template<typename V> void decode(V& v)
58130         {
58131                 v(protocolIEs);
58132
58133         };
58134         template<typename V> void encode(V& v) const
58135         {
58136                 v(protocolIEs);
58137
58138         };
58139         void clear()
58140         {
58141                 protocolIEs.clear();
58142
58143         };
58144         private:
58145         protocolIEs_t   protocolIEs;
58146
58147 };
58148 /*
58149 SeNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
58150         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
58151         { ID id-SeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE optional}|
58152         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                                                              PRESENCE optional}|
58153         { ID id-E-RABs-ToBeReleased-List-RelReq         CRITICALITY ignore      TYPE E-RABs-ToBeReleased-List-RelReq            PRESENCE optional}|
58154         { ID id-UE-ContextKeptIndicator                         CRITICALITY ignore      TYPE UE-ContextKeptIndicator                                    PRESENCE optional}|
58155         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
58156         { ID id-SeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
58157         { ID id-MakeBeforeBreakIndicator                        CRITICALITY ignore      TYPE MakeBeforeBreakIndicator                                   PRESENCE optional},
58158         ...
58159 }
58160 */
58161
58162 struct SeNBReleaseRequest_IEs
58163 {
58164         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58165         {
58166                 size_t get_index() const {return type;}
58167                 bool is_unknown() const { return type == 9; }
58168                 void clear() {type = 0;}
58169                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58170                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
58171                 void select_id_Cause() { set(id_Cause); type=3;}
58172                 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(id_E_RABs_ToBeReleased_List_RelReq); type=4;}
58173                 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
58174                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
58175                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=7;}
58176                 void select_id_MakeBeforeBreakIndicator() { set(id_MakeBeforeBreakIndicator); type=8;}
58177                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58178                 template<typename V>  bool decode(V& v)
58179                 {
58180                         clear();
58181                         if(!v(ref_nested())) return false;
58182                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58183                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
58184                         else if(equal(id_Cause)) { type = 3; return true; }
58185                         else if(equal(id_E_RABs_ToBeReleased_List_RelReq)) { type = 4; return true; }
58186                         else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
58187                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
58188                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
58189                         else if(equal(id_MakeBeforeBreakIndicator)) { type = 8; return true; }
58190                         else { type = 9; return true;}
58191                         return false;
58192
58193                 }
58194                 template<typename V> bool encode(V& v) const
58195                 {
58196                         return v(ref_nested());
58197
58198                 }
58199                 protected:
58200                 template<typename V>  bool decode(size_t index, V& v)
58201                 {
58202                         clear();
58203                         switch(index)
58204                         {
58205                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58206                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
58207                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
58208                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_List_RelReq);} return false;
58209                         case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
58210                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58211                         case 7: type = 7; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
58212                         case 8: type = 8; if(v(ref_nested())) { return equal(id_MakeBeforeBreakIndicator);} return false;
58213                         case 9: type = 9; return v(ref_nested());
58214                         ref_nested().clear();
58215                         }
58216                         return false;
58217
58218                 }
58219                 template<typename V> bool encode(size_t index, V& v) const
58220                 {
58221                         if(index != type) {return false;} return v(ref_nested());
58222
58223                 }
58224                 private:
58225                 size_t type {0};
58226
58227         };
58228         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58229         {
58230                 size_t get_index() const {return type;}
58231                 bool is_unknown() const { return type == 9; }
58232                 void clear() {type = 0;}
58233                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58234                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
58235                 void select_id_Cause() { set(ignore); type=3;}
58236                 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(ignore); type=4;}
58237                 void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
58238                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
58239                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
58240                 void select_id_MakeBeforeBreakIndicator() { set(ignore); type=8;}
58241                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58242                 template<typename V>  bool decode(V& v)
58243                 {
58244                         clear();
58245                         if(!v(ref_nested())) return false;
58246                         if(equal(reject)) { type = 1; return true; }
58247                         else if(equal(reject)) { type = 2; return true; }
58248                         else if(equal(ignore)) { type = 3; return true; }
58249                         else if(equal(ignore)) { type = 4; return true; }
58250                         else if(equal(ignore)) { type = 5; return true; }
58251                         else if(equal(reject)) { type = 6; return true; }
58252                         else if(equal(reject)) { type = 7; return true; }
58253                         else if(equal(ignore)) { type = 8; return true; }
58254                         else { type = 9; return true;}
58255                         return false;
58256
58257                 }
58258                 template<typename V> bool encode(V& v) const
58259                 {
58260                         return v(ref_nested());
58261
58262                 }
58263                 protected:
58264                 template<typename V>  bool decode(size_t index, V& v)
58265                 {
58266                         clear();
58267                         switch(index)
58268                         {
58269                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58270                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58271                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
58272                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
58273                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
58274                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
58275                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
58276                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
58277                         case 9: type = 9; return v(ref_nested());
58278                         ref_nested().clear();
58279                         }
58280                         return false;
58281
58282                 }
58283                 template<typename V> bool encode(size_t index, V& v) const
58284                 {
58285                         if(index != type) {return false;} return v(ref_nested());
58286
58287                 }
58288                 private:
58289                 size_t type {0};
58290
58291         };
58292         struct Value_t : asn::typefield<true>
58293         {
58294                 ~Value_t()      {clear();}
58295                 size_t get_index() const {return type;}
58296                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58297                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58298                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
58299                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
58300                 Cause& select_id_Cause() { return set<Cause>(3); }
58301                 Cause const* get_id_Cause() const { return get<Cause>(3); }
58302                 E_RABs_ToBeReleased_List_RelReq& select_id_E_RABs_ToBeReleased_List_RelReq() { return set<E_RABs_ToBeReleased_List_RelReq>(4); }
58303                 E_RABs_ToBeReleased_List_RelReq const* get_id_E_RABs_ToBeReleased_List_RelReq() const { return get<E_RABs_ToBeReleased_List_RelReq>(4); }
58304                 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
58305                 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
58306                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
58307                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
58308                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
58309                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
58310                 MakeBeforeBreakIndicator& select_id_MakeBeforeBreakIndicator() { return set<MakeBeforeBreakIndicator>(8); }
58311                 MakeBeforeBreakIndicator const* get_id_MakeBeforeBreakIndicator() const { return get<MakeBeforeBreakIndicator>(8); }
58312                 bool is_unknown() const { return type == 9; }
58313                 void clear()
58314                 {
58315                         switch(type)
58316                         {
58317                         case 1: var.destroy<UE_X2AP_ID>(); break;
58318                         case 2: var.destroy<UE_X2AP_ID>(); break;
58319                         case 3: var.destroy<Cause>(); break;
58320                         case 4: var.destroy<E_RABs_ToBeReleased_List_RelReq>(); break;
58321                         case 5: var.destroy<UE_ContextKeptIndicator>(); break;
58322                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
58323                         case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
58324                         case 8: var.destroy<MakeBeforeBreakIndicator>(); break;
58325                         }
58326                         type = 0; ref_nested().clear();
58327                 }
58328                 template<typename V> static inline void enumerate(V& v)
58329                 {
58330                         v.template operator()<UE_X2AP_ID>(1);
58331                         v.template operator()<UE_X2AP_ID>(2);
58332                         v.template operator()<Cause>(3);
58333                         v.template operator()<E_RABs_ToBeReleased_List_RelReq>(4);
58334                         v.template operator()<UE_ContextKeptIndicator>(5);
58335                         v.template operator()<UE_X2AP_ID_Extension>(6);
58336                         v.template operator()<UE_X2AP_ID_Extension>(7);
58337                         v.template operator()<MakeBeforeBreakIndicator>(8);
58338
58339                 }
58340                 protected:
58341                 template<typename V> bool decode(size_t index, V& v)
58342                 {
58343                         clear();
58344                         switch(index)
58345                         {
58346                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58347                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58348                         case 3: v(select_id_Cause()); return true;
58349                         case 4: v(select_id_E_RABs_ToBeReleased_List_RelReq()); return true;
58350                         case 5: v(select_id_UE_ContextKeptIndicator()); return true;
58351                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58352                         case 7: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58353                         case 8: v(select_id_MakeBeforeBreakIndicator()); return true;
58354                         case 9: if(type != 9) {clear(); asn::base::set();} type = 9; return true;
58355                         }
58356                         return false;
58357
58358                 }
58359                 template<typename V> bool encode(size_t index, V& v) const
58360                 {
58361                         if(index != type) return false;
58362                         switch(type)
58363                         {
58364                         case 1: v(var.as<UE_X2AP_ID>()); return true;
58365                         case 2: v(var.as<UE_X2AP_ID>()); return true;
58366                         case 3: v(var.as<Cause>()); return true;
58367                         case 4: v(var.as<E_RABs_ToBeReleased_List_RelReq>()); return true;
58368                         case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
58369                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
58370                         case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
58371                         case 8: v(var.as<MakeBeforeBreakIndicator>()); return true;
58372                         }
58373                         return false;
58374
58375                 }
58376                 private:
58377                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58378                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58379                 union union_type
58380                 {
58381                         char dummy1[sizeof(Cause)];
58382                         char dummy2[sizeof(E_RABs_ToBeReleased_List_RelReq)];
58383                         char dummy3[sizeof(MakeBeforeBreakIndicator)];
58384                         char dummy4[sizeof(UE_ContextKeptIndicator)];
58385                         char dummy5[sizeof(UE_X2AP_ID)];
58386                         char dummy6[sizeof(UE_X2AP_ID_Extension)];
58387
58388                 };
58389                 asn::variant<sizeof(union_type)> var;
58390                 size_t type {0};
58391
58392         };
58393         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58394         {
58395                 size_t get_index() const {return type;}
58396                 bool is_unknown() const { return type == 9; }
58397                 void clear() {type = 0;}
58398                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58399                 void select_id_SeNB_UE_X2AP_ID() { set(optional); type=2;}
58400                 void select_id_Cause() { set(optional); type=3;}
58401                 void select_id_E_RABs_ToBeReleased_List_RelReq() { set(optional); type=4;}
58402                 void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
58403                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
58404                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
58405                 void select_id_MakeBeforeBreakIndicator() { set(optional); type=8;}
58406                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58407                 template<typename V>  bool decode(V& v)
58408                 {
58409                         clear();
58410                         if(!v(ref_nested())) return false;
58411                         if(equal(mandatory)) { type = 1; return true; }
58412                         else if(equal(optional)) { type = 2; return true; }
58413                         else if(equal(optional)) { type = 3; return true; }
58414                         else if(equal(optional)) { type = 4; return true; }
58415                         else if(equal(optional)) { type = 5; return true; }
58416                         else if(equal(optional)) { type = 6; return true; }
58417                         else if(equal(optional)) { type = 7; return true; }
58418                         else if(equal(optional)) { type = 8; return true; }
58419                         else { type = 9; return true;}
58420                         return false;
58421
58422                 }
58423                 template<typename V> bool encode(V& v) const
58424                 {
58425                         return v(ref_nested());
58426
58427                 }
58428                 protected:
58429                 template<typename V>  bool decode(size_t index, V& v)
58430                 {
58431                         clear();
58432                         switch(index)
58433                         {
58434                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58435                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
58436                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
58437                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58438                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58439                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
58440                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
58441                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
58442                         case 9: type = 9; return v(ref_nested());
58443                         ref_nested().clear();
58444                         }
58445                         return false;
58446
58447                 }
58448                 template<typename V> bool encode(size_t index, V& v) const
58449                 {
58450                         if(index != type) {return false;} return v(ref_nested());
58451
58452                 }
58453                 private:
58454                 size_t type {0};
58455
58456         };
58457
58458 };
58459 /*
58460 SeNBReleaseRequest ::= SEQUENCE {
58461         protocolIEs             ProtocolIE-Container            {{SeNBReleaseRequest-IEs}},
58462         ...
58463 }
58464 */
58465
58466 struct SeNBReleaseRequest : asn::sequence<1, 0, true, 0>
58467 {
58468         static constexpr const char* name() {return "SeNBReleaseRequest";}
58469         using parent_t = asn::sequence<1, 0, true, 0>;
58470         struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequest_IEs>
58471         {
58472                 static constexpr const char* name() {return "protocolIEs_t";}
58473                 using parent_t = ProtocolIE_Container<SeNBReleaseRequest_IEs>;
58474
58475         };
58476         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58477         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58478         template<typename V> void decode(V& v)
58479         {
58480                 v(protocolIEs);
58481
58482         };
58483         template<typename V> void encode(V& v) const
58484         {
58485                 v(protocolIEs);
58486
58487         };
58488         void clear()
58489         {
58490                 protocolIEs.clear();
58491
58492         };
58493         private:
58494         protocolIEs_t   protocolIEs;
58495
58496 };
58497 /*
58498 SeNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
58499         { ID id-MeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
58500         { ID id-SeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
58501         { ID id-Cause                                                   CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
58502         { ID id-MeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional}|
58503         { ID id-SeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
58504         ...
58505 }
58506 */
58507
58508 struct SeNBReleaseRequired_IEs
58509 {
58510         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58511         {
58512                 size_t get_index() const {return type;}
58513                 bool is_unknown() const { return type == 6; }
58514                 void clear() {type = 0;}
58515                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58516                 void select_id_SeNB_UE_X2AP_ID() { set(id_SeNB_UE_X2AP_ID); type=2;}
58517                 void select_id_Cause() { set(id_Cause); type=3;}
58518                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
58519                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(id_SeNB_UE_X2AP_ID_Extension); type=5;}
58520                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58521                 template<typename V>  bool decode(V& v)
58522                 {
58523                         clear();
58524                         if(!v(ref_nested())) return false;
58525                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58526                         else if(equal(id_SeNB_UE_X2AP_ID)) { type = 2; return true; }
58527                         else if(equal(id_Cause)) { type = 3; return true; }
58528                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
58529                         else if(equal(id_SeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
58530                         else { type = 6; return true;}
58531                         return false;
58532
58533                 }
58534                 template<typename V> bool encode(V& v) const
58535                 {
58536                         return v(ref_nested());
58537
58538                 }
58539                 protected:
58540                 template<typename V>  bool decode(size_t index, V& v)
58541                 {
58542                         clear();
58543                         switch(index)
58544                         {
58545                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58546                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID);} return false;
58547                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
58548                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58549                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SeNB_UE_X2AP_ID_Extension);} return false;
58550                         case 6: type = 6; return v(ref_nested());
58551                         ref_nested().clear();
58552                         }
58553                         return false;
58554
58555                 }
58556                 template<typename V> bool encode(size_t index, V& v) const
58557                 {
58558                         if(index != type) {return false;} return v(ref_nested());
58559
58560                 }
58561                 private:
58562                 size_t type {0};
58563
58564         };
58565         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58566         {
58567                 size_t get_index() const {return type;}
58568                 bool is_unknown() const { return type == 6; }
58569                 void clear() {type = 0;}
58570                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58571                 void select_id_SeNB_UE_X2AP_ID() { set(reject); type=2;}
58572                 void select_id_Cause() { set(ignore); type=3;}
58573                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
58574                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
58575                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58576                 template<typename V>  bool decode(V& v)
58577                 {
58578                         clear();
58579                         if(!v(ref_nested())) return false;
58580                         if(equal(reject)) { type = 1; return true; }
58581                         else if(equal(reject)) { type = 2; return true; }
58582                         else if(equal(ignore)) { type = 3; return true; }
58583                         else if(equal(reject)) { type = 4; return true; }
58584                         else if(equal(reject)) { type = 5; return true; }
58585                         else { type = 6; return true;}
58586                         return false;
58587
58588                 }
58589                 template<typename V> bool encode(V& v) const
58590                 {
58591                         return v(ref_nested());
58592
58593                 }
58594                 protected:
58595                 template<typename V>  bool decode(size_t index, V& v)
58596                 {
58597                         clear();
58598                         switch(index)
58599                         {
58600                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58601                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58602                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
58603                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
58604                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
58605                         case 6: type = 6; return v(ref_nested());
58606                         ref_nested().clear();
58607                         }
58608                         return false;
58609
58610                 }
58611                 template<typename V> bool encode(size_t index, V& v) const
58612                 {
58613                         if(index != type) {return false;} return v(ref_nested());
58614
58615                 }
58616                 private:
58617                 size_t type {0};
58618
58619         };
58620         struct Value_t : asn::typefield<true>
58621         {
58622                 ~Value_t()      {clear();}
58623                 size_t get_index() const {return type;}
58624                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58625                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58626                 UE_X2AP_ID& select_id_SeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
58627                 UE_X2AP_ID const* get_id_SeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
58628                 Cause& select_id_Cause() { return set<Cause>(3); }
58629                 Cause const* get_id_Cause() const { return get<Cause>(3); }
58630                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
58631                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
58632                 UE_X2AP_ID_Extension& select_id_SeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
58633                 UE_X2AP_ID_Extension const* get_id_SeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
58634                 bool is_unknown() const { return type == 6; }
58635                 void clear()
58636                 {
58637                         switch(type)
58638                         {
58639                         case 1: var.destroy<UE_X2AP_ID>(); break;
58640                         case 2: var.destroy<UE_X2AP_ID>(); break;
58641                         case 3: var.destroy<Cause>(); break;
58642                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
58643                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
58644                         }
58645                         type = 0; ref_nested().clear();
58646                 }
58647                 template<typename V> static inline void enumerate(V& v)
58648                 {
58649                         v.template operator()<UE_X2AP_ID>(1);
58650                         v.template operator()<UE_X2AP_ID>(2);
58651                         v.template operator()<Cause>(3);
58652                         v.template operator()<UE_X2AP_ID_Extension>(4);
58653                         v.template operator()<UE_X2AP_ID_Extension>(5);
58654
58655                 }
58656                 protected:
58657                 template<typename V> bool decode(size_t index, V& v)
58658                 {
58659                         clear();
58660                         switch(index)
58661                         {
58662                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58663                         case 2: v(select_id_SeNB_UE_X2AP_ID()); return true;
58664                         case 3: v(select_id_Cause()); return true;
58665                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58666                         case 5: v(select_id_SeNB_UE_X2AP_ID_Extension()); return true;
58667                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
58668                         }
58669                         return false;
58670
58671                 }
58672                 template<typename V> bool encode(size_t index, V& v) const
58673                 {
58674                         if(index != type) return false;
58675                         switch(type)
58676                         {
58677                         case 1: v(var.as<UE_X2AP_ID>()); return true;
58678                         case 2: v(var.as<UE_X2AP_ID>()); return true;
58679                         case 3: v(var.as<Cause>()); return true;
58680                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
58681                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
58682                         }
58683                         return false;
58684
58685                 }
58686                 private:
58687                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58688                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58689                 union union_type
58690                 {
58691                         char dummy1[sizeof(Cause)];
58692                         char dummy2[sizeof(UE_X2AP_ID)];
58693                         char dummy3[sizeof(UE_X2AP_ID_Extension)];
58694
58695                 };
58696                 asn::variant<sizeof(union_type)> var;
58697                 size_t type {0};
58698
58699         };
58700         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58701         {
58702                 size_t get_index() const {return type;}
58703                 bool is_unknown() const { return type == 6; }
58704                 void clear() {type = 0;}
58705                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58706                 void select_id_SeNB_UE_X2AP_ID() { set(mandatory); type=2;}
58707                 void select_id_Cause() { set(mandatory); type=3;}
58708                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
58709                 void select_id_SeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
58710                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58711                 template<typename V>  bool decode(V& v)
58712                 {
58713                         clear();
58714                         if(!v(ref_nested())) return false;
58715                         if(equal(mandatory)) { type = 1; return true; }
58716                         else if(equal(mandatory)) { type = 2; return true; }
58717                         else if(equal(mandatory)) { type = 3; return true; }
58718                         else if(equal(optional)) { type = 4; return true; }
58719                         else if(equal(optional)) { type = 5; return true; }
58720                         else { type = 6; return true;}
58721                         return false;
58722
58723                 }
58724                 template<typename V> bool encode(V& v) const
58725                 {
58726                         return v(ref_nested());
58727
58728                 }
58729                 protected:
58730                 template<typename V>  bool decode(size_t index, V& v)
58731                 {
58732                         clear();
58733                         switch(index)
58734                         {
58735                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
58736                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
58737                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
58738                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
58739                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
58740                         case 6: type = 6; return v(ref_nested());
58741                         ref_nested().clear();
58742                         }
58743                         return false;
58744
58745                 }
58746                 template<typename V> bool encode(size_t index, V& v) const
58747                 {
58748                         if(index != type) {return false;} return v(ref_nested());
58749
58750                 }
58751                 private:
58752                 size_t type {0};
58753
58754         };
58755
58756 };
58757 /*
58758 SeNBReleaseRequired ::= SEQUENCE {
58759         protocolIEs             ProtocolIE-Container    {{SeNBReleaseRequired-IEs}},
58760         ...
58761 }
58762 */
58763
58764 struct SeNBReleaseRequired : asn::sequence<1, 0, true, 0>
58765 {
58766         static constexpr const char* name() {return "SeNBReleaseRequired";}
58767         using parent_t = asn::sequence<1, 0, true, 0>;
58768         struct protocolIEs_t : ProtocolIE_Container<SeNBReleaseRequired_IEs>
58769         {
58770                 static constexpr const char* name() {return "protocolIEs_t";}
58771                 using parent_t = ProtocolIE_Container<SeNBReleaseRequired_IEs>;
58772
58773         };
58774         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
58775         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
58776         template<typename V> void decode(V& v)
58777         {
58778                 v(protocolIEs);
58779
58780         };
58781         template<typename V> void encode(V& v) const
58782         {
58783                 v(protocolIEs);
58784
58785         };
58786         void clear()
58787         {
58788                 protocolIEs.clear();
58789
58790         };
58791         private:
58792         protocolIEs_t   protocolIEs;
58793
58794 };
58795 /*
58796 SecondaryRATDataUsageReport-IEs X2AP-PROTOCOL-IES ::= {
58797         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                         PRESENCE mandatory}|
58798         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                    PRESENCE mandatory}|
58799         { ID id-SecondaryRATUsageReportList                     CRITICALITY reject      TYPE SecondaryRATUsageReportList                        PRESENCE mandatory}|
58800         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                       PRESENCE optional},
58801         ...
58802 }
58803 */
58804
58805 struct SecondaryRATDataUsageReport_IEs
58806 {
58807         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
58808         {
58809                 size_t get_index() const {return type;}
58810                 bool is_unknown() const { return type == 5; }
58811                 void clear() {type = 0;}
58812                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
58813                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
58814                 void select_id_SecondaryRATUsageReportList() { set(id_SecondaryRATUsageReportList); type=3;}
58815                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
58816                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
58817                 template<typename V>  bool decode(V& v)
58818                 {
58819                         clear();
58820                         if(!v(ref_nested())) return false;
58821                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
58822                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
58823                         else if(equal(id_SecondaryRATUsageReportList)) { type = 3; return true; }
58824                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
58825                         else { type = 5; return true;}
58826                         return false;
58827
58828                 }
58829                 template<typename V> bool encode(V& v) const
58830                 {
58831                         return v(ref_nested());
58832
58833                 }
58834                 protected:
58835                 template<typename V>  bool decode(size_t index, V& v)
58836                 {
58837                         clear();
58838                         switch(index)
58839                         {
58840                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
58841                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
58842                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReportList);} return false;
58843                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
58844                         case 5: type = 5; return v(ref_nested());
58845                         ref_nested().clear();
58846                         }
58847                         return false;
58848
58849                 }
58850                 template<typename V> bool encode(size_t index, V& v) const
58851                 {
58852                         if(index != type) {return false;} return v(ref_nested());
58853
58854                 }
58855                 private:
58856                 size_t type {0};
58857
58858         };
58859         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
58860         {
58861                 size_t get_index() const {return type;}
58862                 bool is_unknown() const { return type == 5; }
58863                 void clear() {type = 0;}
58864                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
58865                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
58866                 void select_id_SecondaryRATUsageReportList() { set(reject); type=3;}
58867                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
58868                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
58869                 template<typename V>  bool decode(V& v)
58870                 {
58871                         clear();
58872                         if(!v(ref_nested())) return false;
58873                         if(equal(reject)) { type = 1; return true; }
58874                         else if(equal(reject)) { type = 2; return true; }
58875                         else if(equal(reject)) { type = 3; return true; }
58876                         else if(equal(reject)) { type = 4; return true; }
58877                         else { type = 5; return true;}
58878                         return false;
58879
58880                 }
58881                 template<typename V> bool encode(V& v) const
58882                 {
58883                         return v(ref_nested());
58884
58885                 }
58886                 protected:
58887                 template<typename V>  bool decode(size_t index, V& v)
58888                 {
58889                         clear();
58890                         switch(index)
58891                         {
58892                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
58893                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
58894                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
58895                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
58896                         case 5: type = 5; return v(ref_nested());
58897                         ref_nested().clear();
58898                         }
58899                         return false;
58900
58901                 }
58902                 template<typename V> bool encode(size_t index, V& v) const
58903                 {
58904                         if(index != type) {return false;} return v(ref_nested());
58905
58906                 }
58907                 private:
58908                 size_t type {0};
58909
58910         };
58911         struct Value_t : asn::typefield<true>
58912         {
58913                 ~Value_t()      {clear();}
58914                 size_t get_index() const {return type;}
58915                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
58916                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
58917                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
58918                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
58919                 SecondaryRATUsageReportList& select_id_SecondaryRATUsageReportList() { return set<SecondaryRATUsageReportList>(3); }
58920                 SecondaryRATUsageReportList const* get_id_SecondaryRATUsageReportList() const { return get<SecondaryRATUsageReportList>(3); }
58921                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
58922                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
58923                 bool is_unknown() const { return type == 5; }
58924                 void clear()
58925                 {
58926                         switch(type)
58927                         {
58928                         case 1: var.destroy<UE_X2AP_ID>(); break;
58929                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
58930                         case 3: var.destroy<SecondaryRATUsageReportList>(); break;
58931                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
58932                         }
58933                         type = 0; ref_nested().clear();
58934                 }
58935                 template<typename V> static inline void enumerate(V& v)
58936                 {
58937                         v.template operator()<UE_X2AP_ID>(1);
58938                         v.template operator()<SgNB_UE_X2AP_ID>(2);
58939                         v.template operator()<SecondaryRATUsageReportList>(3);
58940                         v.template operator()<UE_X2AP_ID_Extension>(4);
58941
58942                 }
58943                 protected:
58944                 template<typename V> bool decode(size_t index, V& v)
58945                 {
58946                         clear();
58947                         switch(index)
58948                         {
58949                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
58950                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
58951                         case 3: v(select_id_SecondaryRATUsageReportList()); return true;
58952                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
58953                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
58954                         }
58955                         return false;
58956
58957                 }
58958                 template<typename V> bool encode(size_t index, V& v) const
58959                 {
58960                         if(index != type) return false;
58961                         switch(type)
58962                         {
58963                         case 1: v(var.as<UE_X2AP_ID>()); return true;
58964                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
58965                         case 3: v(var.as<SecondaryRATUsageReportList>()); return true;
58966                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
58967                         }
58968                         return false;
58969
58970                 }
58971                 private:
58972                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
58973                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
58974                 union union_type
58975                 {
58976                         char dummy1[sizeof(SecondaryRATUsageReportList)];
58977                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
58978                         char dummy3[sizeof(UE_X2AP_ID)];
58979                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
58980
58981                 };
58982                 asn::variant<sizeof(union_type)> var;
58983                 size_t type {0};
58984
58985         };
58986         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
58987         {
58988                 size_t get_index() const {return type;}
58989                 bool is_unknown() const { return type == 5; }
58990                 void clear() {type = 0;}
58991                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
58992                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
58993                 void select_id_SecondaryRATUsageReportList() { set(mandatory); type=3;}
58994                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
58995                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
58996                 template<typename V>  bool decode(V& v)
58997                 {
58998                         clear();
58999                         if(!v(ref_nested())) return false;
59000                         if(equal(mandatory)) { type = 1; return true; }
59001                         else if(equal(mandatory)) { type = 2; return true; }
59002                         else if(equal(mandatory)) { type = 3; return true; }
59003                         else if(equal(optional)) { type = 4; return true; }
59004                         else { type = 5; return true;}
59005                         return false;
59006
59007                 }
59008                 template<typename V> bool encode(V& v) const
59009                 {
59010                         return v(ref_nested());
59011
59012                 }
59013                 protected:
59014                 template<typename V>  bool decode(size_t index, V& v)
59015                 {
59016                         clear();
59017                         switch(index)
59018                         {
59019                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59020                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59021                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
59022                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
59023                         case 5: type = 5; return v(ref_nested());
59024                         ref_nested().clear();
59025                         }
59026                         return false;
59027
59028                 }
59029                 template<typename V> bool encode(size_t index, V& v) const
59030                 {
59031                         if(index != type) {return false;} return v(ref_nested());
59032
59033                 }
59034                 private:
59035                 size_t type {0};
59036
59037         };
59038
59039 };
59040 /*
59041 SecondaryRATDataUsageReport ::= SEQUENCE {
59042         protocolIEs             ProtocolIE-Container            {{SecondaryRATDataUsageReport-IEs}},
59043         ...
59044 }
59045 */
59046
59047 struct SecondaryRATDataUsageReport : asn::sequence<1, 0, true, 0>
59048 {
59049         static constexpr const char* name() {return "SecondaryRATDataUsageReport";}
59050         using parent_t = asn::sequence<1, 0, true, 0>;
59051         struct protocolIEs_t : ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>
59052         {
59053                 static constexpr const char* name() {return "protocolIEs_t";}
59054                 using parent_t = ProtocolIE_Container<SecondaryRATDataUsageReport_IEs>;
59055
59056         };
59057         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59058         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59059         template<typename V> void decode(V& v)
59060         {
59061                 v(protocolIEs);
59062
59063         };
59064         template<typename V> void encode(V& v) const
59065         {
59066                 v(protocolIEs);
59067
59068         };
59069         void clear()
59070         {
59071                 protocolIEs.clear();
59072
59073         };
59074         private:
59075         protocolIEs_t   protocolIEs;
59076
59077 };
59078 /*
59079 SgNBActivityNotification-IEs X2AP-PROTOCOL-IES ::= {
59080         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                         PRESENCE mandatory}|
59081         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                    PRESENCE mandatory}|
59082         { ID id-UEContextLevelUserPlaneActivity         CRITICALITY ignore      TYPE UserPlaneTrafficActivityReport             PRESENCE optional}|
59083         { ID id-ERABActivityNotifyItemList                      CRITICALITY ignore      TYPE ERABActivityNotifyItemList                 PRESENCE optional}|
59084         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                       PRESENCE optional},
59085         ...
59086 }
59087 */
59088
59089 struct SgNBActivityNotification_IEs
59090 {
59091         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59092         {
59093                 size_t get_index() const {return type;}
59094                 bool is_unknown() const { return type == 6; }
59095                 void clear() {type = 0;}
59096                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59097                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
59098                 void select_id_UEContextLevelUserPlaneActivity() { set(id_UEContextLevelUserPlaneActivity); type=3;}
59099                 void select_id_ERABActivityNotifyItemList() { set(id_ERABActivityNotifyItemList); type=4;}
59100                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
59101                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59102                 template<typename V>  bool decode(V& v)
59103                 {
59104                         clear();
59105                         if(!v(ref_nested())) return false;
59106                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59107                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
59108                         else if(equal(id_UEContextLevelUserPlaneActivity)) { type = 3; return true; }
59109                         else if(equal(id_ERABActivityNotifyItemList)) { type = 4; return true; }
59110                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
59111                         else { type = 6; return true;}
59112                         return false;
59113
59114                 }
59115                 template<typename V> bool encode(V& v) const
59116                 {
59117                         return v(ref_nested());
59118
59119                 }
59120                 protected:
59121                 template<typename V>  bool decode(size_t index, V& v)
59122                 {
59123                         clear();
59124                         switch(index)
59125                         {
59126                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59127                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59128                         case 3: type = 3; if(v(ref_nested())) { return equal(id_UEContextLevelUserPlaneActivity);} return false;
59129                         case 4: type = 4; if(v(ref_nested())) { return equal(id_ERABActivityNotifyItemList);} return false;
59130                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59131                         case 6: type = 6; return v(ref_nested());
59132                         ref_nested().clear();
59133                         }
59134                         return false;
59135
59136                 }
59137                 template<typename V> bool encode(size_t index, V& v) const
59138                 {
59139                         if(index != type) {return false;} return v(ref_nested());
59140
59141                 }
59142                 private:
59143                 size_t type {0};
59144
59145         };
59146         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59147         {
59148                 size_t get_index() const {return type;}
59149                 bool is_unknown() const { return type == 6; }
59150                 void clear() {type = 0;}
59151                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59152                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
59153                 void select_id_UEContextLevelUserPlaneActivity() { set(ignore); type=3;}
59154                 void select_id_ERABActivityNotifyItemList() { set(ignore); type=4;}
59155                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
59156                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59157                 template<typename V>  bool decode(V& v)
59158                 {
59159                         clear();
59160                         if(!v(ref_nested())) return false;
59161                         if(equal(reject)) { type = 1; return true; }
59162                         else if(equal(reject)) { type = 2; return true; }
59163                         else if(equal(ignore)) { type = 3; return true; }
59164                         else if(equal(ignore)) { type = 4; return true; }
59165                         else if(equal(reject)) { type = 5; return true; }
59166                         else { type = 6; return true;}
59167                         return false;
59168
59169                 }
59170                 template<typename V> bool encode(V& v) const
59171                 {
59172                         return v(ref_nested());
59173
59174                 }
59175                 protected:
59176                 template<typename V>  bool decode(size_t index, V& v)
59177                 {
59178                         clear();
59179                         switch(index)
59180                         {
59181                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59182                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
59183                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
59184                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
59185                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
59186                         case 6: type = 6; return v(ref_nested());
59187                         ref_nested().clear();
59188                         }
59189                         return false;
59190
59191                 }
59192                 template<typename V> bool encode(size_t index, V& v) const
59193                 {
59194                         if(index != type) {return false;} return v(ref_nested());
59195
59196                 }
59197                 private:
59198                 size_t type {0};
59199
59200         };
59201         struct Value_t : asn::typefield<true>
59202         {
59203                 ~Value_t()      {clear();}
59204                 size_t get_index() const {return type;}
59205                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
59206                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
59207                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
59208                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
59209                 UserPlaneTrafficActivityReport& select_id_UEContextLevelUserPlaneActivity() { return set<UserPlaneTrafficActivityReport>(3); }
59210                 UserPlaneTrafficActivityReport const* get_id_UEContextLevelUserPlaneActivity() const { return get<UserPlaneTrafficActivityReport>(3); }
59211                 ERABActivityNotifyItemList& select_id_ERABActivityNotifyItemList() { return set<ERABActivityNotifyItemList>(4); }
59212                 ERABActivityNotifyItemList const* get_id_ERABActivityNotifyItemList() const { return get<ERABActivityNotifyItemList>(4); }
59213                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
59214                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
59215                 bool is_unknown() const { return type == 6; }
59216                 void clear()
59217                 {
59218                         switch(type)
59219                         {
59220                         case 1: var.destroy<UE_X2AP_ID>(); break;
59221                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
59222                         case 3: var.destroy<UserPlaneTrafficActivityReport>(); break;
59223                         case 4: var.destroy<ERABActivityNotifyItemList>(); break;
59224                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
59225                         }
59226                         type = 0; ref_nested().clear();
59227                 }
59228                 template<typename V> static inline void enumerate(V& v)
59229                 {
59230                         v.template operator()<UE_X2AP_ID>(1);
59231                         v.template operator()<SgNB_UE_X2AP_ID>(2);
59232                         v.template operator()<UserPlaneTrafficActivityReport>(3);
59233                         v.template operator()<ERABActivityNotifyItemList>(4);
59234                         v.template operator()<UE_X2AP_ID_Extension>(5);
59235
59236                 }
59237                 protected:
59238                 template<typename V> bool decode(size_t index, V& v)
59239                 {
59240                         clear();
59241                         switch(index)
59242                         {
59243                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
59244                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
59245                         case 3: v(select_id_UEContextLevelUserPlaneActivity()); return true;
59246                         case 4: v(select_id_ERABActivityNotifyItemList()); return true;
59247                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
59248                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
59249                         }
59250                         return false;
59251
59252                 }
59253                 template<typename V> bool encode(size_t index, V& v) const
59254                 {
59255                         if(index != type) return false;
59256                         switch(type)
59257                         {
59258                         case 1: v(var.as<UE_X2AP_ID>()); return true;
59259                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
59260                         case 3: v(var.as<UserPlaneTrafficActivityReport>()); return true;
59261                         case 4: v(var.as<ERABActivityNotifyItemList>()); return true;
59262                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
59263                         }
59264                         return false;
59265
59266                 }
59267                 private:
59268                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
59269                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
59270                 union union_type
59271                 {
59272                         char dummy1[sizeof(ERABActivityNotifyItemList)];
59273                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
59274                         char dummy3[sizeof(UE_X2AP_ID)];
59275                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
59276                         char dummy5[sizeof(UserPlaneTrafficActivityReport)];
59277
59278                 };
59279                 asn::variant<sizeof(union_type)> var;
59280                 size_t type {0};
59281
59282         };
59283         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
59284         {
59285                 size_t get_index() const {return type;}
59286                 bool is_unknown() const { return type == 6; }
59287                 void clear() {type = 0;}
59288                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
59289                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
59290                 void select_id_UEContextLevelUserPlaneActivity() { set(optional); type=3;}
59291                 void select_id_ERABActivityNotifyItemList() { set(optional); type=4;}
59292                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
59293                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
59294                 template<typename V>  bool decode(V& v)
59295                 {
59296                         clear();
59297                         if(!v(ref_nested())) return false;
59298                         if(equal(mandatory)) { type = 1; return true; }
59299                         else if(equal(mandatory)) { type = 2; return true; }
59300                         else if(equal(optional)) { type = 3; return true; }
59301                         else if(equal(optional)) { type = 4; return true; }
59302                         else if(equal(optional)) { type = 5; return true; }
59303                         else { type = 6; return true;}
59304                         return false;
59305
59306                 }
59307                 template<typename V> bool encode(V& v) const
59308                 {
59309                         return v(ref_nested());
59310
59311                 }
59312                 protected:
59313                 template<typename V>  bool decode(size_t index, V& v)
59314                 {
59315                         clear();
59316                         switch(index)
59317                         {
59318                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59319                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59320                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
59321                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
59322                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
59323                         case 6: type = 6; return v(ref_nested());
59324                         ref_nested().clear();
59325                         }
59326                         return false;
59327
59328                 }
59329                 template<typename V> bool encode(size_t index, V& v) const
59330                 {
59331                         if(index != type) {return false;} return v(ref_nested());
59332
59333                 }
59334                 private:
59335                 size_t type {0};
59336
59337         };
59338
59339 };
59340 /*
59341 SgNBActivityNotification ::= SEQUENCE {
59342         protocolIEs             ProtocolIE-Container            {{SgNBActivityNotification-IEs}},
59343         ...
59344 }
59345 */
59346
59347 struct SgNBActivityNotification : asn::sequence<1, 0, true, 0>
59348 {
59349         static constexpr const char* name() {return "SgNBActivityNotification";}
59350         using parent_t = asn::sequence<1, 0, true, 0>;
59351         struct protocolIEs_t : ProtocolIE_Container<SgNBActivityNotification_IEs>
59352         {
59353                 static constexpr const char* name() {return "protocolIEs_t";}
59354                 using parent_t = ProtocolIE_Container<SgNBActivityNotification_IEs>;
59355
59356         };
59357         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59358         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59359         template<typename V> void decode(V& v)
59360         {
59361                 v(protocolIEs);
59362
59363         };
59364         template<typename V> void encode(V& v) const
59365         {
59366                 v(protocolIEs);
59367
59368         };
59369         void clear()
59370         {
59371                 protocolIEs.clear();
59372
59373         };
59374         private:
59375         protocolIEs_t   protocolIEs;
59376
59377 };
59378 /*
59379 SgNBAdditionRequest-IEs X2AP-PROTOCOL-IES ::= {
59380         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
59381         { ID id-NRUESecurityCapabilities                                        CRITICALITY reject      TYPE NRUESecurityCapabilities                                   PRESENCE mandatory}|
59382         { ID id-SgNBSecurityKey                                                 CRITICALITY reject      TYPE SgNBSecurityKey                                                                    PRESENCE mandatory}|
59383         { ID id-SgNBUEAggregateMaximumBitRate                   CRITICALITY reject      TYPE UEAggregateMaximumBitRate                                  PRESENCE mandatory}|
59384         { ID id-SelectedPLMN                                                            CRITICALITY ignore      TYPE PLMN-Identity                                                                      PRESENCE optional}|
59385         { ID id-HandoverRestrictionList                                 CRITICALITY ignore      TYPE HandoverRestrictionList                                            PRESENCE optional}|
59386         { ID id-E-RABs-ToBeAdded-SgNBAddReqList                 CRITICALITY reject      TYPE E-RABs-ToBeAdded-SgNBAddReqList                    PRESENCE mandatory}|
59387         { ID id-MeNBtoSgNBContainer                                             CRITICALITY reject      TYPE MeNBtoSgNBContainer                                                                PRESENCE mandatory}|
59388         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE optional}|
59389         { ID id-ExpectedUEBehaviour                                             CRITICALITY ignore      TYPE ExpectedUEBehaviour                                                                PRESENCE optional}|
59390         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
59391         { ID id-RequestedSplitSRBs                                              CRITICALITY reject      TYPE SplitSRBs                                                                          PRESENCE optional}|
59392         { ID id-MeNBResourceCoordinationInformation             CRITICALITY ignore      TYPE MeNBResourceCoordinationInformation                PRESENCE optional}|
59393         { ID id-SGNB-Addition-Trigger-Ind                               CRITICALITY reject      TYPE SGNB-Addition-Trigger-Ind                                  PRESENCE optional}|
59394         { ID id-SubscriberProfileIDforRFP                               CRITICALITY ignore      TYPE SubscriberProfileIDforRFP                                  PRESENCE optional}|
59395         { ID id-MeNBCell-ID                                                             CRITICALITY reject      TYPE ECGI                                                                                       PRESENCE mandatory},
59396         ...
59397 }
59398 */
59399
59400 struct SgNBAdditionRequest_IEs
59401 {
59402         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59403         {
59404                 size_t get_index() const {return type;}
59405                 bool is_unknown() const { return type == 17; }
59406                 void clear() {type = 0;}
59407                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59408                 void select_id_NRUESecurityCapabilities() { set(id_NRUESecurityCapabilities); type=2;}
59409                 void select_id_SgNBSecurityKey() { set(id_SgNBSecurityKey); type=3;}
59410                 void select_id_SgNBUEAggregateMaximumBitRate() { set(id_SgNBUEAggregateMaximumBitRate); type=4;}
59411                 void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=5;}
59412                 void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=6;}
59413                 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(id_E_RABs_ToBeAdded_SgNBAddReqList); type=7;}
59414                 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
59415                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=9;}
59416                 void select_id_ExpectedUEBehaviour() { set(id_ExpectedUEBehaviour); type=10;}
59417                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=11;}
59418                 void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=12;}
59419                 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=13;}
59420                 void select_id_SGNB_Addition_Trigger_Ind() { set(id_SGNB_Addition_Trigger_Ind); type=14;}
59421                 void select_id_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); type=15;}
59422                 void select_id_MeNBCell_ID() { set(id_MeNBCell_ID); type=16;}
59423                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59424                 template<typename V>  bool decode(V& v)
59425                 {
59426                         clear();
59427                         if(!v(ref_nested())) return false;
59428                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59429                         else if(equal(id_NRUESecurityCapabilities)) { type = 2; return true; }
59430                         else if(equal(id_SgNBSecurityKey)) { type = 3; return true; }
59431                         else if(equal(id_SgNBUEAggregateMaximumBitRate)) { type = 4; return true; }
59432                         else if(equal(id_SelectedPLMN)) { type = 5; return true; }
59433                         else if(equal(id_HandoverRestrictionList)) { type = 6; return true; }
59434                         else if(equal(id_E_RABs_ToBeAdded_SgNBAddReqList)) { type = 7; return true; }
59435                         else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
59436                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 9; return true; }
59437                         else if(equal(id_ExpectedUEBehaviour)) { type = 10; return true; }
59438                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 11; return true; }
59439                         else if(equal(id_RequestedSplitSRBs)) { type = 12; return true; }
59440                         else if(equal(id_MeNBResourceCoordinationInformation)) { type = 13; return true; }
59441                         else if(equal(id_SGNB_Addition_Trigger_Ind)) { type = 14; return true; }
59442                         else if(equal(id_SubscriberProfileIDforRFP)) { type = 15; return true; }
59443                         else if(equal(id_MeNBCell_ID)) { type = 16; return true; }
59444                         else { type = 17; return true;}
59445                         return false;
59446
59447                 }
59448                 template<typename V> bool encode(V& v) const
59449                 {
59450                         return v(ref_nested());
59451
59452                 }
59453                 protected:
59454                 template<typename V>  bool decode(size_t index, V& v)
59455                 {
59456                         clear();
59457                         switch(index)
59458                         {
59459                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59460                         case 2: type = 2; if(v(ref_nested())) { return equal(id_NRUESecurityCapabilities);} return false;
59461                         case 3: type = 3; if(v(ref_nested())) { return equal(id_SgNBSecurityKey);} return false;
59462                         case 4: type = 4; if(v(ref_nested())) { return equal(id_SgNBUEAggregateMaximumBitRate);} return false;
59463                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
59464                         case 6: type = 6; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
59465                         case 7: type = 7; if(v(ref_nested())) { return equal(id_E_RABs_ToBeAdded_SgNBAddReqList);} return false;
59466                         case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
59467                         case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59468                         case 10: type = 10; if(v(ref_nested())) { return equal(id_ExpectedUEBehaviour);} return false;
59469                         case 11: type = 11; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59470                         case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
59471                         case 13: type = 13; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
59472                         case 14: type = 14; if(v(ref_nested())) { return equal(id_SGNB_Addition_Trigger_Ind);} return false;
59473                         case 15: type = 15; if(v(ref_nested())) { return equal(id_SubscriberProfileIDforRFP);} return false;
59474                         case 16: type = 16; if(v(ref_nested())) { return equal(id_MeNBCell_ID);} return false;
59475                         case 17: type = 17; return v(ref_nested());
59476                         ref_nested().clear();
59477                         }
59478                         return false;
59479
59480                 }
59481                 template<typename V> bool encode(size_t index, V& v) const
59482                 {
59483                         if(index != type) {return false;} return v(ref_nested());
59484
59485                 }
59486                 private:
59487                 size_t type {0};
59488
59489         };
59490         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59491         {
59492                 size_t get_index() const {return type;}
59493                 bool is_unknown() const { return type == 17; }
59494                 void clear() {type = 0;}
59495                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59496                 void select_id_NRUESecurityCapabilities() { set(reject); type=2;}
59497                 void select_id_SgNBSecurityKey() { set(reject); type=3;}
59498                 void select_id_SgNBUEAggregateMaximumBitRate() { set(reject); type=4;}
59499                 void select_id_SelectedPLMN() { set(ignore); type=5;}
59500                 void select_id_HandoverRestrictionList() { set(ignore); type=6;}
59501                 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(reject); type=7;}
59502                 void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
59503                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=9;}
59504                 void select_id_ExpectedUEBehaviour() { set(ignore); type=10;}
59505                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=11;}
59506                 void select_id_RequestedSplitSRBs() { set(reject); type=12;}
59507                 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=13;}
59508                 void select_id_SGNB_Addition_Trigger_Ind() { set(reject); type=14;}
59509                 void select_id_SubscriberProfileIDforRFP() { set(ignore); type=15;}
59510                 void select_id_MeNBCell_ID() { set(reject); type=16;}
59511                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59512                 template<typename V>  bool decode(V& v)
59513                 {
59514                         clear();
59515                         if(!v(ref_nested())) return false;
59516                         if(equal(reject)) { type = 1; return true; }
59517                         else if(equal(reject)) { type = 2; return true; }
59518                         else if(equal(reject)) { type = 3; return true; }
59519                         else if(equal(reject)) { type = 4; return true; }
59520                         else if(equal(ignore)) { type = 5; return true; }
59521                         else if(equal(ignore)) { type = 6; return true; }
59522                         else if(equal(reject)) { type = 7; return true; }
59523                         else if(equal(reject)) { type = 8; return true; }
59524                         else if(equal(reject)) { type = 9; return true; }
59525                         else if(equal(ignore)) { type = 10; return true; }
59526                         else if(equal(reject)) { type = 11; return true; }
59527                         else if(equal(reject)) { type = 12; return true; }
59528                         else if(equal(ignore)) { type = 13; return true; }
59529                         else if(equal(reject)) { type = 14; return true; }
59530                         else if(equal(ignore)) { type = 15; return true; }
59531                         else if(equal(reject)) { type = 16; return true; }
59532                         else { type = 17; return true;}
59533                         return false;
59534
59535                 }
59536                 template<typename V> bool encode(V& v) const
59537                 {
59538                         return v(ref_nested());
59539
59540                 }
59541                 protected:
59542                 template<typename V>  bool decode(size_t index, V& v)
59543                 {
59544                         clear();
59545                         switch(index)
59546                         {
59547                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59548                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
59549                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
59550                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
59551                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
59552                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
59553                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
59554                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
59555                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
59556                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
59557                         case 11: type = 11; if(v(ref_nested())) { return equal(reject);} return false;
59558                         case 12: type = 12; if(v(ref_nested())) { return equal(reject);} return false;
59559                         case 13: type = 13; if(v(ref_nested())) { return equal(ignore);} return false;
59560                         case 14: type = 14; if(v(ref_nested())) { return equal(reject);} return false;
59561                         case 15: type = 15; if(v(ref_nested())) { return equal(ignore);} return false;
59562                         case 16: type = 16; if(v(ref_nested())) { return equal(reject);} return false;
59563                         case 17: type = 17; return v(ref_nested());
59564                         ref_nested().clear();
59565                         }
59566                         return false;
59567
59568                 }
59569                 template<typename V> bool encode(size_t index, V& v) const
59570                 {
59571                         if(index != type) {return false;} return v(ref_nested());
59572
59573                 }
59574                 private:
59575                 size_t type {0};
59576
59577         };
59578         struct Value_t : asn::typefield<true>
59579         {
59580                 ~Value_t()      {clear();}
59581                 size_t get_index() const {return type;}
59582                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
59583                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
59584                 NRUESecurityCapabilities& select_id_NRUESecurityCapabilities() { return set<NRUESecurityCapabilities>(2); }
59585                 NRUESecurityCapabilities const* get_id_NRUESecurityCapabilities() const { return get<NRUESecurityCapabilities>(2); }
59586                 SgNBSecurityKey& select_id_SgNBSecurityKey() { return set<SgNBSecurityKey>(3); }
59587                 SgNBSecurityKey const* get_id_SgNBSecurityKey() const { return get<SgNBSecurityKey>(3); }
59588                 UEAggregateMaximumBitRate& select_id_SgNBUEAggregateMaximumBitRate() { return set<UEAggregateMaximumBitRate>(4); }
59589                 UEAggregateMaximumBitRate const* get_id_SgNBUEAggregateMaximumBitRate() const { return get<UEAggregateMaximumBitRate>(4); }
59590                 PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(5); }
59591                 PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(5); }
59592                 HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(6); }
59593                 HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(6); }
59594                 E_RABs_ToBeAdded_SgNBAddReqList& select_id_E_RABs_ToBeAdded_SgNBAddReqList() { return set<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
59595                 E_RABs_ToBeAdded_SgNBAddReqList const* get_id_E_RABs_ToBeAdded_SgNBAddReqList() const { return get<E_RABs_ToBeAdded_SgNBAddReqList>(7); }
59596                 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
59597                 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
59598                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(9); }
59599                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(9); }
59600                 ExpectedUEBehaviour& select_id_ExpectedUEBehaviour() { return set<ExpectedUEBehaviour>(10); }
59601                 ExpectedUEBehaviour const* get_id_ExpectedUEBehaviour() const { return get<ExpectedUEBehaviour>(10); }
59602                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(11); }
59603                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(11); }
59604                 SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(12); }
59605                 SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(12); }
59606                 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(13); }
59607                 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(13); }
59608                 SGNB_Addition_Trigger_Ind& select_id_SGNB_Addition_Trigger_Ind() { return set<SGNB_Addition_Trigger_Ind>(14); }
59609                 SGNB_Addition_Trigger_Ind const* get_id_SGNB_Addition_Trigger_Ind() const { return get<SGNB_Addition_Trigger_Ind>(14); }
59610                 SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(15); }
59611                 SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(15); }
59612                 ECGI& select_id_MeNBCell_ID() { return set<ECGI>(16); }
59613                 ECGI const* get_id_MeNBCell_ID() const { return get<ECGI>(16); }
59614                 bool is_unknown() const { return type == 17; }
59615                 void clear()
59616                 {
59617                         switch(type)
59618                         {
59619                         case 1: var.destroy<UE_X2AP_ID>(); break;
59620                         case 2: var.destroy<NRUESecurityCapabilities>(); break;
59621                         case 3: var.destroy<SgNBSecurityKey>(); break;
59622                         case 4: var.destroy<UEAggregateMaximumBitRate>(); break;
59623                         case 5: var.destroy<PLMN_Identity>(); break;
59624                         case 6: var.destroy<HandoverRestrictionList>(); break;
59625                         case 7: var.destroy<E_RABs_ToBeAdded_SgNBAddReqList>(); break;
59626                         case 8: var.destroy<MeNBtoSgNBContainer>(); break;
59627                         case 9: var.destroy<SgNB_UE_X2AP_ID>(); break;
59628                         case 10: var.destroy<ExpectedUEBehaviour>(); break;
59629                         case 11: var.destroy<UE_X2AP_ID_Extension>(); break;
59630                         case 12: var.destroy<SplitSRBs>(); break;
59631                         case 13: var.destroy<MeNBResourceCoordinationInformation>(); break;
59632                         case 14: var.destroy<SGNB_Addition_Trigger_Ind>(); break;
59633                         case 15: var.destroy<SubscriberProfileIDforRFP>(); break;
59634                         case 16: var.destroy<ECGI>(); break;
59635                         }
59636                         type = 0; ref_nested().clear();
59637                 }
59638                 template<typename V> static inline void enumerate(V& v)
59639                 {
59640                         v.template operator()<UE_X2AP_ID>(1);
59641                         v.template operator()<NRUESecurityCapabilities>(2);
59642                         v.template operator()<SgNBSecurityKey>(3);
59643                         v.template operator()<UEAggregateMaximumBitRate>(4);
59644                         v.template operator()<PLMN_Identity>(5);
59645                         v.template operator()<HandoverRestrictionList>(6);
59646                         v.template operator()<E_RABs_ToBeAdded_SgNBAddReqList>(7);
59647                         v.template operator()<MeNBtoSgNBContainer>(8);
59648                         v.template operator()<SgNB_UE_X2AP_ID>(9);
59649                         v.template operator()<ExpectedUEBehaviour>(10);
59650                         v.template operator()<UE_X2AP_ID_Extension>(11);
59651                         v.template operator()<SplitSRBs>(12);
59652                         v.template operator()<MeNBResourceCoordinationInformation>(13);
59653                         v.template operator()<SGNB_Addition_Trigger_Ind>(14);
59654                         v.template operator()<SubscriberProfileIDforRFP>(15);
59655                         v.template operator()<ECGI>(16);
59656
59657                 }
59658                 protected:
59659                 template<typename V> bool decode(size_t index, V& v)
59660                 {
59661                         clear();
59662                         switch(index)
59663                         {
59664                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
59665                         case 2: v(select_id_NRUESecurityCapabilities()); return true;
59666                         case 3: v(select_id_SgNBSecurityKey()); return true;
59667                         case 4: v(select_id_SgNBUEAggregateMaximumBitRate()); return true;
59668                         case 5: v(select_id_SelectedPLMN()); return true;
59669                         case 6: v(select_id_HandoverRestrictionList()); return true;
59670                         case 7: v(select_id_E_RABs_ToBeAdded_SgNBAddReqList()); return true;
59671                         case 8: v(select_id_MeNBtoSgNBContainer()); return true;
59672                         case 9: v(select_id_SgNB_UE_X2AP_ID()); return true;
59673                         case 10: v(select_id_ExpectedUEBehaviour()); return true;
59674                         case 11: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
59675                         case 12: v(select_id_RequestedSplitSRBs()); return true;
59676                         case 13: v(select_id_MeNBResourceCoordinationInformation()); return true;
59677                         case 14: v(select_id_SGNB_Addition_Trigger_Ind()); return true;
59678                         case 15: v(select_id_SubscriberProfileIDforRFP()); return true;
59679                         case 16: v(select_id_MeNBCell_ID()); return true;
59680                         case 17: if(type != 17) {clear(); asn::base::set();} type = 17; return true;
59681                         }
59682                         return false;
59683
59684                 }
59685                 template<typename V> bool encode(size_t index, V& v) const
59686                 {
59687                         if(index != type) return false;
59688                         switch(type)
59689                         {
59690                         case 1: v(var.as<UE_X2AP_ID>()); return true;
59691                         case 2: v(var.as<NRUESecurityCapabilities>()); return true;
59692                         case 3: v(var.as<SgNBSecurityKey>()); return true;
59693                         case 4: v(var.as<UEAggregateMaximumBitRate>()); return true;
59694                         case 5: v(var.as<PLMN_Identity>()); return true;
59695                         case 6: v(var.as<HandoverRestrictionList>()); return true;
59696                         case 7: v(var.as<E_RABs_ToBeAdded_SgNBAddReqList>()); return true;
59697                         case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
59698                         case 9: v(var.as<SgNB_UE_X2AP_ID>()); return true;
59699                         case 10: v(var.as<ExpectedUEBehaviour>()); return true;
59700                         case 11: v(var.as<UE_X2AP_ID_Extension>()); return true;
59701                         case 12: v(var.as<SplitSRBs>()); return true;
59702                         case 13: v(var.as<MeNBResourceCoordinationInformation>()); return true;
59703                         case 14: v(var.as<SGNB_Addition_Trigger_Ind>()); return true;
59704                         case 15: v(var.as<SubscriberProfileIDforRFP>()); return true;
59705                         case 16: v(var.as<ECGI>()); return true;
59706                         }
59707                         return false;
59708
59709                 }
59710                 private:
59711                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
59712                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
59713                 union union_type
59714                 {
59715                         char dummy1[sizeof(ECGI)];
59716                         char dummy2[sizeof(E_RABs_ToBeAdded_SgNBAddReqList)];
59717                         char dummy3[sizeof(ExpectedUEBehaviour)];
59718                         char dummy4[sizeof(HandoverRestrictionList)];
59719                         char dummy5[sizeof(MeNBResourceCoordinationInformation)];
59720                         char dummy6[sizeof(MeNBtoSgNBContainer)];
59721                         char dummy7[sizeof(NRUESecurityCapabilities)];
59722                         char dummy8[sizeof(PLMN_Identity)];
59723                         char dummy9[sizeof(SGNB_Addition_Trigger_Ind)];
59724                         char dummy10[sizeof(SgNBSecurityKey)];
59725                         char dummy11[sizeof(SgNB_UE_X2AP_ID)];
59726                         char dummy12[sizeof(SplitSRBs)];
59727                         char dummy13[sizeof(SubscriberProfileIDforRFP)];
59728                         char dummy14[sizeof(UEAggregateMaximumBitRate)];
59729                         char dummy15[sizeof(UE_X2AP_ID)];
59730                         char dummy16[sizeof(UE_X2AP_ID_Extension)];
59731
59732                 };
59733                 asn::variant<sizeof(union_type)> var;
59734                 size_t type {0};
59735
59736         };
59737         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
59738         {
59739                 size_t get_index() const {return type;}
59740                 bool is_unknown() const { return type == 17; }
59741                 void clear() {type = 0;}
59742                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
59743                 void select_id_NRUESecurityCapabilities() { set(mandatory); type=2;}
59744                 void select_id_SgNBSecurityKey() { set(mandatory); type=3;}
59745                 void select_id_SgNBUEAggregateMaximumBitRate() { set(mandatory); type=4;}
59746                 void select_id_SelectedPLMN() { set(optional); type=5;}
59747                 void select_id_HandoverRestrictionList() { set(optional); type=6;}
59748                 void select_id_E_RABs_ToBeAdded_SgNBAddReqList() { set(mandatory); type=7;}
59749                 void select_id_MeNBtoSgNBContainer() { set(mandatory); type=8;}
59750                 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=9;}
59751                 void select_id_ExpectedUEBehaviour() { set(optional); type=10;}
59752                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=11;}
59753                 void select_id_RequestedSplitSRBs() { set(optional); type=12;}
59754                 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=13;}
59755                 void select_id_SGNB_Addition_Trigger_Ind() { set(optional); type=14;}
59756                 void select_id_SubscriberProfileIDforRFP() { set(optional); type=15;}
59757                 void select_id_MeNBCell_ID() { set(mandatory); type=16;}
59758                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
59759                 template<typename V>  bool decode(V& v)
59760                 {
59761                         clear();
59762                         if(!v(ref_nested())) return false;
59763                         if(equal(mandatory)) { type = 1; return true; }
59764                         else if(equal(mandatory)) { type = 2; return true; }
59765                         else if(equal(mandatory)) { type = 3; return true; }
59766                         else if(equal(mandatory)) { type = 4; return true; }
59767                         else if(equal(optional)) { type = 5; return true; }
59768                         else if(equal(optional)) { type = 6; return true; }
59769                         else if(equal(mandatory)) { type = 7; return true; }
59770                         else if(equal(mandatory)) { type = 8; return true; }
59771                         else if(equal(optional)) { type = 9; return true; }
59772                         else if(equal(optional)) { type = 10; return true; }
59773                         else if(equal(optional)) { type = 11; return true; }
59774                         else if(equal(optional)) { type = 12; return true; }
59775                         else if(equal(optional)) { type = 13; return true; }
59776                         else if(equal(optional)) { type = 14; return true; }
59777                         else if(equal(optional)) { type = 15; return true; }
59778                         else if(equal(mandatory)) { type = 16; return true; }
59779                         else { type = 17; return true;}
59780                         return false;
59781
59782                 }
59783                 template<typename V> bool encode(V& v) const
59784                 {
59785                         return v(ref_nested());
59786
59787                 }
59788                 protected:
59789                 template<typename V>  bool decode(size_t index, V& v)
59790                 {
59791                         clear();
59792                         switch(index)
59793                         {
59794                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
59795                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
59796                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
59797                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
59798                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
59799                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
59800                         case 7: type = 7; if(v(ref_nested())) { return equal(mandatory);} return false;
59801                         case 8: type = 8; if(v(ref_nested())) { return equal(mandatory);} return false;
59802                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
59803                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
59804                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
59805                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
59806                         case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
59807                         case 14: type = 14; if(v(ref_nested())) { return equal(optional);} return false;
59808                         case 15: type = 15; if(v(ref_nested())) { return equal(optional);} return false;
59809                         case 16: type = 16; if(v(ref_nested())) { return equal(mandatory);} return false;
59810                         case 17: type = 17; return v(ref_nested());
59811                         ref_nested().clear();
59812                         }
59813                         return false;
59814
59815                 }
59816                 template<typename V> bool encode(size_t index, V& v) const
59817                 {
59818                         if(index != type) {return false;} return v(ref_nested());
59819
59820                 }
59821                 private:
59822                 size_t type {0};
59823
59824         };
59825
59826 };
59827 /*
59828 SgNBAdditionRequest ::= SEQUENCE {
59829         protocolIEs             ProtocolIE-Container {{SgNBAdditionRequest-IEs}},
59830         ...
59831 }
59832 */
59833
59834 struct SgNBAdditionRequest : asn::sequence<1, 0, true, 0>
59835 {
59836         static constexpr const char* name() {return "SgNBAdditionRequest";}
59837         using parent_t = asn::sequence<1, 0, true, 0>;
59838         struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequest_IEs>
59839         {
59840                 static constexpr const char* name() {return "protocolIEs_t";}
59841                 using parent_t = ProtocolIE_Container<SgNBAdditionRequest_IEs>;
59842
59843         };
59844         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
59845         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
59846         template<typename V> void decode(V& v)
59847         {
59848                 v(protocolIEs);
59849
59850         };
59851         template<typename V> void encode(V& v) const
59852         {
59853                 v(protocolIEs);
59854
59855         };
59856         void clear()
59857         {
59858                 protocolIEs.clear();
59859
59860         };
59861         private:
59862         protocolIEs_t   protocolIEs;
59863
59864 };
59865 /*
59866 SgNBAdditionRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
59867         { ID id-MeNB-UE-X2AP-ID                                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                                                 PRESENCE mandatory}|
59868         { ID id-SgNB-UE-X2AP-ID                                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                                            PRESENCE mandatory}|
59869         { ID id-E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList     CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-SgNBAddReqAckList                        PRESENCE mandatory}|
59870         { ID id-E-RABs-NotAdmitted-List                                         CRITICALITY ignore      TYPE E-RAB-List                                                                                                 PRESENCE optional}|
59871         { ID id-SgNBtoMeNBContainer                                                     CRITICALITY reject      TYPE SgNBtoMeNBContainer                                                                                PRESENCE mandatory}|
59872         { ID id-CriticalityDiagnostics                                          CRITICALITY ignore      TYPE CriticalityDiagnostics                                                                     PRESENCE optional}|
59873         { ID id-MeNB-UE-X2AP-ID-Extension                                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                                       PRESENCE optional}|
59874         { ID id-AdmittedSplitSRBs                                                       CRITICALITY reject      TYPE SplitSRBs                                                                                                  PRESENCE optional}|
59875         { ID id-SgNBResourceCoordinationInformation                     CRITICALITY ignore      TYPE SgNBResourceCoordinationInformation                                PRESENCE optional}|
59876         { ID id-RRCConfigIndication                                                     CRITICALITY reject      TYPE RRC-Config-Ind                                                                                             PRESENCE optional},
59877         ...
59878 }
59879 */
59880
59881 struct SgNBAdditionRequestAcknowledge_IEs
59882 {
59883         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
59884         {
59885                 size_t get_index() const {return type;}
59886                 bool is_unknown() const { return type == 11; }
59887                 void clear() {type = 0;}
59888                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
59889                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
59890                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList); type=3;}
59891                 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=4;}
59892                 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
59893                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=6;}
59894                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
59895                 void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=8;}
59896                 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
59897                 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
59898                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
59899                 template<typename V>  bool decode(V& v)
59900                 {
59901                         clear();
59902                         if(!v(ref_nested())) return false;
59903                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
59904                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
59905                         else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)) { type = 3; return true; }
59906                         else if(equal(id_E_RABs_NotAdmitted_List)) { type = 4; return true; }
59907                         else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
59908                         else if(equal(id_CriticalityDiagnostics)) { type = 6; return true; }
59909                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
59910                         else if(equal(id_AdmittedSplitSRBs)) { type = 8; return true; }
59911                         else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
59912                         else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
59913                         else { type = 11; return true;}
59914                         return false;
59915
59916                 }
59917                 template<typename V> bool encode(V& v) const
59918                 {
59919                         return v(ref_nested());
59920
59921                 }
59922                 protected:
59923                 template<typename V>  bool decode(size_t index, V& v)
59924                 {
59925                         clear();
59926                         switch(index)
59927                         {
59928                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
59929                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
59930                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);} return false;
59931                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
59932                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
59933                         case 6: type = 6; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
59934                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
59935                         case 8: type = 8; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
59936                         case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
59937                         case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
59938                         case 11: type = 11; return v(ref_nested());
59939                         ref_nested().clear();
59940                         }
59941                         return false;
59942
59943                 }
59944                 template<typename V> bool encode(size_t index, V& v) const
59945                 {
59946                         if(index != type) {return false;} return v(ref_nested());
59947
59948                 }
59949                 private:
59950                 size_t type {0};
59951
59952         };
59953         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
59954         {
59955                 size_t get_index() const {return type;}
59956                 bool is_unknown() const { return type == 11; }
59957                 void clear() {type = 0;}
59958                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
59959                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
59960                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(ignore); type=3;}
59961                 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=4;}
59962                 void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
59963                 void select_id_CriticalityDiagnostics() { set(ignore); type=6;}
59964                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
59965                 void select_id_AdmittedSplitSRBs() { set(reject); type=8;}
59966                 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
59967                 void select_id_RRCConfigIndication() { set(reject); type=10;}
59968                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
59969                 template<typename V>  bool decode(V& v)
59970                 {
59971                         clear();
59972                         if(!v(ref_nested())) return false;
59973                         if(equal(reject)) { type = 1; return true; }
59974                         else if(equal(reject)) { type = 2; return true; }
59975                         else if(equal(ignore)) { type = 3; return true; }
59976                         else if(equal(ignore)) { type = 4; return true; }
59977                         else if(equal(reject)) { type = 5; return true; }
59978                         else if(equal(ignore)) { type = 6; return true; }
59979                         else if(equal(reject)) { type = 7; return true; }
59980                         else if(equal(reject)) { type = 8; return true; }
59981                         else if(equal(ignore)) { type = 9; return true; }
59982                         else if(equal(reject)) { type = 10; return true; }
59983                         else { type = 11; return true;}
59984                         return false;
59985
59986                 }
59987                 template<typename V> bool encode(V& v) const
59988                 {
59989                         return v(ref_nested());
59990
59991                 }
59992                 protected:
59993                 template<typename V>  bool decode(size_t index, V& v)
59994                 {
59995                         clear();
59996                         switch(index)
59997                         {
59998                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
59999                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
60000                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60001                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60002                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60003                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
60004                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
60005                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
60006                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
60007                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
60008                         case 11: type = 11; return v(ref_nested());
60009                         ref_nested().clear();
60010                         }
60011                         return false;
60012
60013                 }
60014                 template<typename V> bool encode(size_t index, V& v) const
60015                 {
60016                         if(index != type) {return false;} return v(ref_nested());
60017
60018                 }
60019                 private:
60020                 size_t type {0};
60021
60022         };
60023         struct Value_t : asn::typefield<true>
60024         {
60025                 ~Value_t()      {clear();}
60026                 size_t get_index() const {return type;}
60027                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60028                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60029                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60030                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60031                 E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
60032                 E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3); }
60033                 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(4); }
60034                 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(4); }
60035                 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
60036                 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
60037                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(6); }
60038                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(6); }
60039                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
60040                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
60041                 SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(8); }
60042                 SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(8); }
60043                 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
60044                 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
60045                 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
60046                 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
60047                 bool is_unknown() const { return type == 11; }
60048                 void clear()
60049                 {
60050                         switch(type)
60051                         {
60052                         case 1: var.destroy<UE_X2AP_ID>(); break;
60053                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60054                         case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(); break;
60055                         case 4: var.destroy<E_RAB_List>(); break;
60056                         case 5: var.destroy<SgNBtoMeNBContainer>(); break;
60057                         case 6: var.destroy<CriticalityDiagnostics>(); break;
60058                         case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
60059                         case 8: var.destroy<SplitSRBs>(); break;
60060                         case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
60061                         case 10: var.destroy<RRC_Config_Ind>(); break;
60062                         }
60063                         type = 0; ref_nested().clear();
60064                 }
60065                 template<typename V> static inline void enumerate(V& v)
60066                 {
60067                         v.template operator()<UE_X2AP_ID>(1);
60068                         v.template operator()<SgNB_UE_X2AP_ID>(2);
60069                         v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>(3);
60070                         v.template operator()<E_RAB_List>(4);
60071                         v.template operator()<SgNBtoMeNBContainer>(5);
60072                         v.template operator()<CriticalityDiagnostics>(6);
60073                         v.template operator()<UE_X2AP_ID_Extension>(7);
60074                         v.template operator()<SplitSRBs>(8);
60075                         v.template operator()<SgNBResourceCoordinationInformation>(9);
60076                         v.template operator()<RRC_Config_Ind>(10);
60077
60078                 }
60079                 protected:
60080                 template<typename V> bool decode(size_t index, V& v)
60081                 {
60082                         clear();
60083                         switch(index)
60084                         {
60085                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60086                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60087                         case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList()); return true;
60088                         case 4: v(select_id_E_RABs_NotAdmitted_List()); return true;
60089                         case 5: v(select_id_SgNBtoMeNBContainer()); return true;
60090                         case 6: v(select_id_CriticalityDiagnostics()); return true;
60091                         case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60092                         case 8: v(select_id_AdmittedSplitSRBs()); return true;
60093                         case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
60094                         case 10: v(select_id_RRCConfigIndication()); return true;
60095                         case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
60096                         }
60097                         return false;
60098
60099                 }
60100                 template<typename V> bool encode(size_t index, V& v) const
60101                 {
60102                         if(index != type) return false;
60103                         switch(type)
60104                         {
60105                         case 1: v(var.as<UE_X2AP_ID>()); return true;
60106                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60107                         case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList>()); return true;
60108                         case 4: v(var.as<E_RAB_List>()); return true;
60109                         case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
60110                         case 6: v(var.as<CriticalityDiagnostics>()); return true;
60111                         case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
60112                         case 8: v(var.as<SplitSRBs>()); return true;
60113                         case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
60114                         case 10: v(var.as<RRC_Config_Ind>()); return true;
60115                         }
60116                         return false;
60117
60118                 }
60119                 private:
60120                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60121                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60122                 union union_type
60123                 {
60124                         char dummy1[sizeof(CriticalityDiagnostics)];
60125                         char dummy2[sizeof(E_RAB_List)];
60126                         char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList)];
60127                         char dummy4[sizeof(RRC_Config_Ind)];
60128                         char dummy5[sizeof(SgNBResourceCoordinationInformation)];
60129                         char dummy6[sizeof(SgNB_UE_X2AP_ID)];
60130                         char dummy7[sizeof(SgNBtoMeNBContainer)];
60131                         char dummy8[sizeof(SplitSRBs)];
60132                         char dummy9[sizeof(UE_X2AP_ID)];
60133                         char dummy10[sizeof(UE_X2AP_ID_Extension)];
60134
60135                 };
60136                 asn::variant<sizeof(union_type)> var;
60137                 size_t type {0};
60138
60139         };
60140         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60141         {
60142                 size_t get_index() const {return type;}
60143                 bool is_unknown() const { return type == 11; }
60144                 void clear() {type = 0;}
60145                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60146                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
60147                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList() { set(mandatory); type=3;}
60148                 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=4;}
60149                 void select_id_SgNBtoMeNBContainer() { set(mandatory); type=5;}
60150                 void select_id_CriticalityDiagnostics() { set(optional); type=6;}
60151                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
60152                 void select_id_AdmittedSplitSRBs() { set(optional); type=8;}
60153                 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
60154                 void select_id_RRCConfigIndication() { set(optional); type=10;}
60155                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60156                 template<typename V>  bool decode(V& v)
60157                 {
60158                         clear();
60159                         if(!v(ref_nested())) return false;
60160                         if(equal(mandatory)) { type = 1; return true; }
60161                         else if(equal(mandatory)) { type = 2; return true; }
60162                         else if(equal(mandatory)) { type = 3; return true; }
60163                         else if(equal(optional)) { type = 4; return true; }
60164                         else if(equal(mandatory)) { type = 5; return true; }
60165                         else if(equal(optional)) { type = 6; return true; }
60166                         else if(equal(optional)) { type = 7; return true; }
60167                         else if(equal(optional)) { type = 8; return true; }
60168                         else if(equal(optional)) { type = 9; return true; }
60169                         else if(equal(optional)) { type = 10; return true; }
60170                         else { type = 11; return true;}
60171                         return false;
60172
60173                 }
60174                 template<typename V> bool encode(V& v) const
60175                 {
60176                         return v(ref_nested());
60177
60178                 }
60179                 protected:
60180                 template<typename V>  bool decode(size_t index, V& v)
60181                 {
60182                         clear();
60183                         switch(index)
60184                         {
60185                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60186                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
60187                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
60188                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60189                         case 5: type = 5; if(v(ref_nested())) { return equal(mandatory);} return false;
60190                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
60191                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
60192                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
60193                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
60194                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
60195                         case 11: type = 11; return v(ref_nested());
60196                         ref_nested().clear();
60197                         }
60198                         return false;
60199
60200                 }
60201                 template<typename V> bool encode(size_t index, V& v) const
60202                 {
60203                         if(index != type) {return false;} return v(ref_nested());
60204
60205                 }
60206                 private:
60207                 size_t type {0};
60208
60209         };
60210
60211 };
60212 /*
60213 SgNBAdditionRequestAcknowledge ::= SEQUENCE {
60214         protocolIEs             ProtocolIE-Container    {{SgNBAdditionRequestAcknowledge-IEs}},
60215         ...
60216 }
60217 */
60218
60219 struct SgNBAdditionRequestAcknowledge : asn::sequence<1, 0, true, 0>
60220 {
60221         static constexpr const char* name() {return "SgNBAdditionRequestAcknowledge";}
60222         using parent_t = asn::sequence<1, 0, true, 0>;
60223         struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>
60224         {
60225                 static constexpr const char* name() {return "protocolIEs_t";}
60226                 using parent_t = ProtocolIE_Container<SgNBAdditionRequestAcknowledge_IEs>;
60227
60228         };
60229         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60230         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60231         template<typename V> void decode(V& v)
60232         {
60233                 v(protocolIEs);
60234
60235         };
60236         template<typename V> void encode(V& v) const
60237         {
60238                 v(protocolIEs);
60239
60240         };
60241         void clear()
60242         {
60243                 protocolIEs.clear();
60244
60245         };
60246         private:
60247         protocolIEs_t   protocolIEs;
60248
60249 };
60250 /*
60251 SgNBAdditionRequestReject-IEs X2AP-PROTOCOL-IES ::= {
60252         { ID id-MeNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
60253         { ID id-SgNB-UE-X2AP-ID                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                    PRESENCE optional}|
60254         { ID id-Cause                                                   CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
60255         { ID id-CriticalityDiagnostics                  CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
60256         { ID id-MeNB-UE-X2AP-ID-Extension               CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
60257         ...
60258 }
60259 */
60260
60261 struct SgNBAdditionRequestReject_IEs
60262 {
60263         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60264         {
60265                 size_t get_index() const {return type;}
60266                 bool is_unknown() const { return type == 6; }
60267                 void clear() {type = 0;}
60268                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60269                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60270                 void select_id_Cause() { set(id_Cause); type=3;}
60271                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60272                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60273                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60274                 template<typename V>  bool decode(V& v)
60275                 {
60276                         clear();
60277                         if(!v(ref_nested())) return false;
60278                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60279                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60280                         else if(equal(id_Cause)) { type = 3; return true; }
60281                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60282                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60283                         else { type = 6; return true;}
60284                         return false;
60285
60286                 }
60287                 template<typename V> bool encode(V& v) const
60288                 {
60289                         return v(ref_nested());
60290
60291                 }
60292                 protected:
60293                 template<typename V>  bool decode(size_t index, V& v)
60294                 {
60295                         clear();
60296                         switch(index)
60297                         {
60298                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60299                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60300                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
60301                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60302                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60303                         case 6: type = 6; return v(ref_nested());
60304                         ref_nested().clear();
60305                         }
60306                         return false;
60307
60308                 }
60309                 template<typename V> bool encode(size_t index, V& v) const
60310                 {
60311                         if(index != type) {return false;} return v(ref_nested());
60312
60313                 }
60314                 private:
60315                 size_t type {0};
60316
60317         };
60318         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60319         {
60320                 size_t get_index() const {return type;}
60321                 bool is_unknown() const { return type == 6; }
60322                 void clear() {type = 0;}
60323                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
60324                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
60325                 void select_id_Cause() { set(ignore); type=3;}
60326                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60327                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
60328                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60329                 template<typename V>  bool decode(V& v)
60330                 {
60331                         clear();
60332                         if(!v(ref_nested())) return false;
60333                         if(equal(reject)) { type = 1; return true; }
60334                         else if(equal(reject)) { type = 2; return true; }
60335                         else if(equal(ignore)) { type = 3; return true; }
60336                         else if(equal(ignore)) { type = 4; return true; }
60337                         else if(equal(reject)) { type = 5; return true; }
60338                         else { type = 6; return true;}
60339                         return false;
60340
60341                 }
60342                 template<typename V> bool encode(V& v) const
60343                 {
60344                         return v(ref_nested());
60345
60346                 }
60347                 protected:
60348                 template<typename V>  bool decode(size_t index, V& v)
60349                 {
60350                         clear();
60351                         switch(index)
60352                         {
60353                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
60354                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
60355                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60356                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60357                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60358                         case 6: type = 6; return v(ref_nested());
60359                         ref_nested().clear();
60360                         }
60361                         return false;
60362
60363                 }
60364                 template<typename V> bool encode(size_t index, V& v) const
60365                 {
60366                         if(index != type) {return false;} return v(ref_nested());
60367
60368                 }
60369                 private:
60370                 size_t type {0};
60371
60372         };
60373         struct Value_t : asn::typefield<true>
60374         {
60375                 ~Value_t()      {clear();}
60376                 size_t get_index() const {return type;}
60377                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60378                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60379                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60380                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60381                 Cause& select_id_Cause() { return set<Cause>(3); }
60382                 Cause const* get_id_Cause() const { return get<Cause>(3); }
60383                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60384                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60385                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60386                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60387                 bool is_unknown() const { return type == 6; }
60388                 void clear()
60389                 {
60390                         switch(type)
60391                         {
60392                         case 1: var.destroy<UE_X2AP_ID>(); break;
60393                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60394                         case 3: var.destroy<Cause>(); break;
60395                         case 4: var.destroy<CriticalityDiagnostics>(); break;
60396                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60397                         }
60398                         type = 0; ref_nested().clear();
60399                 }
60400                 template<typename V> static inline void enumerate(V& v)
60401                 {
60402                         v.template operator()<UE_X2AP_ID>(1);
60403                         v.template operator()<SgNB_UE_X2AP_ID>(2);
60404                         v.template operator()<Cause>(3);
60405                         v.template operator()<CriticalityDiagnostics>(4);
60406                         v.template operator()<UE_X2AP_ID_Extension>(5);
60407
60408                 }
60409                 protected:
60410                 template<typename V> bool decode(size_t index, V& v)
60411                 {
60412                         clear();
60413                         switch(index)
60414                         {
60415                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60416                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60417                         case 3: v(select_id_Cause()); return true;
60418                         case 4: v(select_id_CriticalityDiagnostics()); return true;
60419                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60420                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
60421                         }
60422                         return false;
60423
60424                 }
60425                 template<typename V> bool encode(size_t index, V& v) const
60426                 {
60427                         if(index != type) return false;
60428                         switch(type)
60429                         {
60430                         case 1: v(var.as<UE_X2AP_ID>()); return true;
60431                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60432                         case 3: v(var.as<Cause>()); return true;
60433                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
60434                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
60435                         }
60436                         return false;
60437
60438                 }
60439                 private:
60440                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60441                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60442                 union union_type
60443                 {
60444                         char dummy1[sizeof(Cause)];
60445                         char dummy2[sizeof(CriticalityDiagnostics)];
60446                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
60447                         char dummy4[sizeof(UE_X2AP_ID)];
60448                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
60449
60450                 };
60451                 asn::variant<sizeof(union_type)> var;
60452                 size_t type {0};
60453
60454         };
60455         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60456         {
60457                 size_t get_index() const {return type;}
60458                 bool is_unknown() const { return type == 6; }
60459                 void clear() {type = 0;}
60460                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60461                 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
60462                 void select_id_Cause() { set(mandatory); type=3;}
60463                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
60464                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
60465                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60466                 template<typename V>  bool decode(V& v)
60467                 {
60468                         clear();
60469                         if(!v(ref_nested())) return false;
60470                         if(equal(mandatory)) { type = 1; return true; }
60471                         else if(equal(optional)) { type = 2; return true; }
60472                         else if(equal(mandatory)) { type = 3; return true; }
60473                         else if(equal(optional)) { type = 4; return true; }
60474                         else if(equal(optional)) { type = 5; return true; }
60475                         else { type = 6; return true;}
60476                         return false;
60477
60478                 }
60479                 template<typename V> bool encode(V& v) const
60480                 {
60481                         return v(ref_nested());
60482
60483                 }
60484                 protected:
60485                 template<typename V>  bool decode(size_t index, V& v)
60486                 {
60487                         clear();
60488                         switch(index)
60489                         {
60490                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60491                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
60492                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
60493                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60494                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
60495                         case 6: type = 6; return v(ref_nested());
60496                         ref_nested().clear();
60497                         }
60498                         return false;
60499
60500                 }
60501                 template<typename V> bool encode(size_t index, V& v) const
60502                 {
60503                         if(index != type) {return false;} return v(ref_nested());
60504
60505                 }
60506                 private:
60507                 size_t type {0};
60508
60509         };
60510
60511 };
60512 /*
60513 SgNBAdditionRequestReject ::= SEQUENCE {
60514         protocolIEs             ProtocolIE-Container    {{SgNBAdditionRequestReject-IEs}},
60515         ...
60516 }
60517 */
60518
60519 struct SgNBAdditionRequestReject : asn::sequence<1, 0, true, 0>
60520 {
60521         static constexpr const char* name() {return "SgNBAdditionRequestReject";}
60522         using parent_t = asn::sequence<1, 0, true, 0>;
60523         struct protocolIEs_t : ProtocolIE_Container<SgNBAdditionRequestReject_IEs>
60524         {
60525                 static constexpr const char* name() {return "protocolIEs_t";}
60526                 using parent_t = ProtocolIE_Container<SgNBAdditionRequestReject_IEs>;
60527
60528         };
60529         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60530         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60531         template<typename V> void decode(V& v)
60532         {
60533                 v(protocolIEs);
60534
60535         };
60536         template<typename V> void encode(V& v) const
60537         {
60538                 v(protocolIEs);
60539
60540         };
60541         void clear()
60542         {
60543                 protocolIEs.clear();
60544
60545         };
60546         private:
60547         protocolIEs_t   protocolIEs;
60548
60549 };
60550 /*
60551 SgNBChangeConfirm-IEs X2AP-PROTOCOL-IES ::= {
60552         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
60553         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE mandatory}|
60554         { ID id-E-RABs-ToBeReleased-SgNBChaConfList             CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBChaConfList                PRESENCE optional}|
60555         { ID id-CriticalityDiagnostics                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional}|
60556         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional},
60557         ...
60558 }
60559 */
60560
60561 struct SgNBChangeConfirm_IEs
60562 {
60563         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60564         {
60565                 size_t get_index() const {return type;}
60566                 bool is_unknown() const { return type == 6; }
60567                 void clear() {type = 0;}
60568                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60569                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60570                 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(id_E_RABs_ToBeReleased_SgNBChaConfList); type=3;}
60571                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60572                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60573                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60574                 template<typename V>  bool decode(V& v)
60575                 {
60576                         clear();
60577                         if(!v(ref_nested())) return false;
60578                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60579                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60580                         else if(equal(id_E_RABs_ToBeReleased_SgNBChaConfList)) { type = 3; return true; }
60581                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60582                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60583                         else { type = 6; return true;}
60584                         return false;
60585
60586                 }
60587                 template<typename V> bool encode(V& v) const
60588                 {
60589                         return v(ref_nested());
60590
60591                 }
60592                 protected:
60593                 template<typename V>  bool decode(size_t index, V& v)
60594                 {
60595                         clear();
60596                         switch(index)
60597                         {
60598                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60599                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60600                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBChaConfList);} return false;
60601                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60602                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60603                         case 6: type = 6; return v(ref_nested());
60604                         ref_nested().clear();
60605                         }
60606                         return false;
60607
60608                 }
60609                 template<typename V> bool encode(size_t index, V& v) const
60610                 {
60611                         if(index != type) {return false;} return v(ref_nested());
60612
60613                 }
60614                 private:
60615                 size_t type {0};
60616
60617         };
60618         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60619         {
60620                 size_t get_index() const {return type;}
60621                 bool is_unknown() const { return type == 6; }
60622                 void clear() {type = 0;}
60623                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
60624                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
60625                 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(ignore); type=3;}
60626                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60627                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
60628                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60629                 template<typename V>  bool decode(V& v)
60630                 {
60631                         clear();
60632                         if(!v(ref_nested())) return false;
60633                         if(equal(ignore)) { type = 1; return true; }
60634                         else if(equal(ignore)) { type = 2; return true; }
60635                         else if(equal(ignore)) { type = 3; return true; }
60636                         else if(equal(ignore)) { type = 4; return true; }
60637                         else if(equal(ignore)) { type = 5; return true; }
60638                         else { type = 6; return true;}
60639                         return false;
60640
60641                 }
60642                 template<typename V> bool encode(V& v) const
60643                 {
60644                         return v(ref_nested());
60645
60646                 }
60647                 protected:
60648                 template<typename V>  bool decode(size_t index, V& v)
60649                 {
60650                         clear();
60651                         switch(index)
60652                         {
60653                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
60654                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
60655                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60656                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60657                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
60658                         case 6: type = 6; return v(ref_nested());
60659                         ref_nested().clear();
60660                         }
60661                         return false;
60662
60663                 }
60664                 template<typename V> bool encode(size_t index, V& v) const
60665                 {
60666                         if(index != type) {return false;} return v(ref_nested());
60667
60668                 }
60669                 private:
60670                 size_t type {0};
60671
60672         };
60673         struct Value_t : asn::typefield<true>
60674         {
60675                 ~Value_t()      {clear();}
60676                 size_t get_index() const {return type;}
60677                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60678                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60679                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60680                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60681                 E_RABs_ToBeReleased_SgNBChaConfList& select_id_E_RABs_ToBeReleased_SgNBChaConfList() { return set<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
60682                 E_RABs_ToBeReleased_SgNBChaConfList const* get_id_E_RABs_ToBeReleased_SgNBChaConfList() const { return get<E_RABs_ToBeReleased_SgNBChaConfList>(3); }
60683                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60684                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60685                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60686                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60687                 bool is_unknown() const { return type == 6; }
60688                 void clear()
60689                 {
60690                         switch(type)
60691                         {
60692                         case 1: var.destroy<UE_X2AP_ID>(); break;
60693                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60694                         case 3: var.destroy<E_RABs_ToBeReleased_SgNBChaConfList>(); break;
60695                         case 4: var.destroy<CriticalityDiagnostics>(); break;
60696                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60697                         }
60698                         type = 0; ref_nested().clear();
60699                 }
60700                 template<typename V> static inline void enumerate(V& v)
60701                 {
60702                         v.template operator()<UE_X2AP_ID>(1);
60703                         v.template operator()<SgNB_UE_X2AP_ID>(2);
60704                         v.template operator()<E_RABs_ToBeReleased_SgNBChaConfList>(3);
60705                         v.template operator()<CriticalityDiagnostics>(4);
60706                         v.template operator()<UE_X2AP_ID_Extension>(5);
60707
60708                 }
60709                 protected:
60710                 template<typename V> bool decode(size_t index, V& v)
60711                 {
60712                         clear();
60713                         switch(index)
60714                         {
60715                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
60716                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
60717                         case 3: v(select_id_E_RABs_ToBeReleased_SgNBChaConfList()); return true;
60718                         case 4: v(select_id_CriticalityDiagnostics()); return true;
60719                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
60720                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
60721                         }
60722                         return false;
60723
60724                 }
60725                 template<typename V> bool encode(size_t index, V& v) const
60726                 {
60727                         if(index != type) return false;
60728                         switch(type)
60729                         {
60730                         case 1: v(var.as<UE_X2AP_ID>()); return true;
60731                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
60732                         case 3: v(var.as<E_RABs_ToBeReleased_SgNBChaConfList>()); return true;
60733                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
60734                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
60735                         }
60736                         return false;
60737
60738                 }
60739                 private:
60740                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
60741                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
60742                 union union_type
60743                 {
60744                         char dummy1[sizeof(CriticalityDiagnostics)];
60745                         char dummy2[sizeof(E_RABs_ToBeReleased_SgNBChaConfList)];
60746                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
60747                         char dummy4[sizeof(UE_X2AP_ID)];
60748                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
60749
60750                 };
60751                 asn::variant<sizeof(union_type)> var;
60752                 size_t type {0};
60753
60754         };
60755         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
60756         {
60757                 size_t get_index() const {return type;}
60758                 bool is_unknown() const { return type == 6; }
60759                 void clear() {type = 0;}
60760                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
60761                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
60762                 void select_id_E_RABs_ToBeReleased_SgNBChaConfList() { set(optional); type=3;}
60763                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
60764                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
60765                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
60766                 template<typename V>  bool decode(V& v)
60767                 {
60768                         clear();
60769                         if(!v(ref_nested())) return false;
60770                         if(equal(mandatory)) { type = 1; return true; }
60771                         else if(equal(mandatory)) { type = 2; return true; }
60772                         else if(equal(optional)) { type = 3; return true; }
60773                         else if(equal(optional)) { type = 4; return true; }
60774                         else if(equal(optional)) { type = 5; return true; }
60775                         else { type = 6; return true;}
60776                         return false;
60777
60778                 }
60779                 template<typename V> bool encode(V& v) const
60780                 {
60781                         return v(ref_nested());
60782
60783                 }
60784                 protected:
60785                 template<typename V>  bool decode(size_t index, V& v)
60786                 {
60787                         clear();
60788                         switch(index)
60789                         {
60790                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
60791                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
60792                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
60793                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
60794                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
60795                         case 6: type = 6; return v(ref_nested());
60796                         ref_nested().clear();
60797                         }
60798                         return false;
60799
60800                 }
60801                 template<typename V> bool encode(size_t index, V& v) const
60802                 {
60803                         if(index != type) {return false;} return v(ref_nested());
60804
60805                 }
60806                 private:
60807                 size_t type {0};
60808
60809         };
60810
60811 };
60812 /*
60813 SgNBChangeConfirm ::= SEQUENCE {
60814         protocolIEs             ProtocolIE-Container    {{SgNBChangeConfirm-IEs}},
60815         ...
60816 }
60817 */
60818
60819 struct SgNBChangeConfirm : asn::sequence<1, 0, true, 0>
60820 {
60821         static constexpr const char* name() {return "SgNBChangeConfirm";}
60822         using parent_t = asn::sequence<1, 0, true, 0>;
60823         struct protocolIEs_t : ProtocolIE_Container<SgNBChangeConfirm_IEs>
60824         {
60825                 static constexpr const char* name() {return "protocolIEs_t";}
60826                 using parent_t = ProtocolIE_Container<SgNBChangeConfirm_IEs>;
60827
60828         };
60829         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
60830         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
60831         template<typename V> void decode(V& v)
60832         {
60833                 v(protocolIEs);
60834
60835         };
60836         template<typename V> void encode(V& v) const
60837         {
60838                 v(protocolIEs);
60839
60840         };
60841         void clear()
60842         {
60843                 protocolIEs.clear();
60844
60845         };
60846         private:
60847         protocolIEs_t   protocolIEs;
60848
60849 };
60850 /*
60851 SgNBChangeRefuse-IEs X2AP-PROTOCOL-IES ::= {
60852         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
60853         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                            PRESENCE mandatory}|
60854         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
60855         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
60856         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
60857         ...
60858 }
60859 */
60860
60861 struct SgNBChangeRefuse_IEs
60862 {
60863         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
60864         {
60865                 size_t get_index() const {return type;}
60866                 bool is_unknown() const { return type == 6; }
60867                 void clear() {type = 0;}
60868                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
60869                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
60870                 void select_id_Cause() { set(id_Cause); type=3;}
60871                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
60872                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
60873                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
60874                 template<typename V>  bool decode(V& v)
60875                 {
60876                         clear();
60877                         if(!v(ref_nested())) return false;
60878                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
60879                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
60880                         else if(equal(id_Cause)) { type = 3; return true; }
60881                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
60882                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
60883                         else { type = 6; return true;}
60884                         return false;
60885
60886                 }
60887                 template<typename V> bool encode(V& v) const
60888                 {
60889                         return v(ref_nested());
60890
60891                 }
60892                 protected:
60893                 template<typename V>  bool decode(size_t index, V& v)
60894                 {
60895                         clear();
60896                         switch(index)
60897                         {
60898                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
60899                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
60900                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
60901                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
60902                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
60903                         case 6: type = 6; return v(ref_nested());
60904                         ref_nested().clear();
60905                         }
60906                         return false;
60907
60908                 }
60909                 template<typename V> bool encode(size_t index, V& v) const
60910                 {
60911                         if(index != type) {return false;} return v(ref_nested());
60912
60913                 }
60914                 private:
60915                 size_t type {0};
60916
60917         };
60918         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
60919         {
60920                 size_t get_index() const {return type;}
60921                 bool is_unknown() const { return type == 6; }
60922                 void clear() {type = 0;}
60923                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
60924                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
60925                 void select_id_Cause() { set(ignore); type=3;}
60926                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
60927                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
60928                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
60929                 template<typename V>  bool decode(V& v)
60930                 {
60931                         clear();
60932                         if(!v(ref_nested())) return false;
60933                         if(equal(ignore)) { type = 1; return true; }
60934                         else if(equal(ignore)) { type = 2; return true; }
60935                         else if(equal(ignore)) { type = 3; return true; }
60936                         else if(equal(ignore)) { type = 4; return true; }
60937                         else if(equal(reject)) { type = 5; return true; }
60938                         else { type = 6; return true;}
60939                         return false;
60940
60941                 }
60942                 template<typename V> bool encode(V& v) const
60943                 {
60944                         return v(ref_nested());
60945
60946                 }
60947                 protected:
60948                 template<typename V>  bool decode(size_t index, V& v)
60949                 {
60950                         clear();
60951                         switch(index)
60952                         {
60953                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
60954                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
60955                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
60956                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
60957                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
60958                         case 6: type = 6; return v(ref_nested());
60959                         ref_nested().clear();
60960                         }
60961                         return false;
60962
60963                 }
60964                 template<typename V> bool encode(size_t index, V& v) const
60965                 {
60966                         if(index != type) {return false;} return v(ref_nested());
60967
60968                 }
60969                 private:
60970                 size_t type {0};
60971
60972         };
60973         struct Value_t : asn::typefield<true>
60974         {
60975                 ~Value_t()      {clear();}
60976                 size_t get_index() const {return type;}
60977                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
60978                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
60979                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
60980                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
60981                 Cause& select_id_Cause() { return set<Cause>(3); }
60982                 Cause const* get_id_Cause() const { return get<Cause>(3); }
60983                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
60984                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
60985                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
60986                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
60987                 bool is_unknown() const { return type == 6; }
60988                 void clear()
60989                 {
60990                         switch(type)
60991                         {
60992                         case 1: var.destroy<UE_X2AP_ID>(); break;
60993                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
60994                         case 3: var.destroy<Cause>(); break;
60995                         case 4: var.destroy<CriticalityDiagnostics>(); break;
60996                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
60997                         }
60998                         type = 0; ref_nested().clear();
60999                 }
61000                 template<typename V> static inline void enumerate(V& v)
61001                 {
61002                         v.template operator()<UE_X2AP_ID>(1);
61003                         v.template operator()<SgNB_UE_X2AP_ID>(2);
61004                         v.template operator()<Cause>(3);
61005                         v.template operator()<CriticalityDiagnostics>(4);
61006                         v.template operator()<UE_X2AP_ID_Extension>(5);
61007
61008                 }
61009                 protected:
61010                 template<typename V> bool decode(size_t index, V& v)
61011                 {
61012                         clear();
61013                         switch(index)
61014                         {
61015                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61016                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61017                         case 3: v(select_id_Cause()); return true;
61018                         case 4: v(select_id_CriticalityDiagnostics()); return true;
61019                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61020                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
61021                         }
61022                         return false;
61023
61024                 }
61025                 template<typename V> bool encode(size_t index, V& v) const
61026                 {
61027                         if(index != type) return false;
61028                         switch(type)
61029                         {
61030                         case 1: v(var.as<UE_X2AP_ID>()); return true;
61031                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61032                         case 3: v(var.as<Cause>()); return true;
61033                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
61034                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
61035                         }
61036                         return false;
61037
61038                 }
61039                 private:
61040                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61041                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61042                 union union_type
61043                 {
61044                         char dummy1[sizeof(Cause)];
61045                         char dummy2[sizeof(CriticalityDiagnostics)];
61046                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
61047                         char dummy4[sizeof(UE_X2AP_ID)];
61048                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
61049
61050                 };
61051                 asn::variant<sizeof(union_type)> var;
61052                 size_t type {0};
61053
61054         };
61055         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61056         {
61057                 size_t get_index() const {return type;}
61058                 bool is_unknown() const { return type == 6; }
61059                 void clear() {type = 0;}
61060                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61061                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61062                 void select_id_Cause() { set(mandatory); type=3;}
61063                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
61064                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
61065                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61066                 template<typename V>  bool decode(V& v)
61067                 {
61068                         clear();
61069                         if(!v(ref_nested())) return false;
61070                         if(equal(mandatory)) { type = 1; return true; }
61071                         else if(equal(mandatory)) { type = 2; return true; }
61072                         else if(equal(mandatory)) { type = 3; return true; }
61073                         else if(equal(optional)) { type = 4; return true; }
61074                         else if(equal(optional)) { type = 5; return true; }
61075                         else { type = 6; return true;}
61076                         return false;
61077
61078                 }
61079                 template<typename V> bool encode(V& v) const
61080                 {
61081                         return v(ref_nested());
61082
61083                 }
61084                 protected:
61085                 template<typename V>  bool decode(size_t index, V& v)
61086                 {
61087                         clear();
61088                         switch(index)
61089                         {
61090                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61091                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61092                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61093                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
61094                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
61095                         case 6: type = 6; return v(ref_nested());
61096                         ref_nested().clear();
61097                         }
61098                         return false;
61099
61100                 }
61101                 template<typename V> bool encode(size_t index, V& v) const
61102                 {
61103                         if(index != type) {return false;} return v(ref_nested());
61104
61105                 }
61106                 private:
61107                 size_t type {0};
61108
61109         };
61110
61111 };
61112 /*
61113 SgNBChangeRefuse ::= SEQUENCE {
61114         protocolIEs             ProtocolIE-Container            {{SgNBChangeRefuse-IEs}},
61115         ...
61116 }
61117 */
61118
61119 struct SgNBChangeRefuse : asn::sequence<1, 0, true, 0>
61120 {
61121         static constexpr const char* name() {return "SgNBChangeRefuse";}
61122         using parent_t = asn::sequence<1, 0, true, 0>;
61123         struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRefuse_IEs>
61124         {
61125                 static constexpr const char* name() {return "protocolIEs_t";}
61126                 using parent_t = ProtocolIE_Container<SgNBChangeRefuse_IEs>;
61127
61128         };
61129         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61130         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61131         template<typename V> void decode(V& v)
61132         {
61133                 v(protocolIEs);
61134
61135         };
61136         template<typename V> void encode(V& v) const
61137         {
61138                 v(protocolIEs);
61139
61140         };
61141         void clear()
61142         {
61143                 protocolIEs.clear();
61144
61145         };
61146         private:
61147         protocolIEs_t   protocolIEs;
61148
61149 };
61150 /*
61151 SgNBChangeRequired-IEs X2AP-PROTOCOL-IES ::= {
61152         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
61153         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                            PRESENCE mandatory}|
61154         { ID id-Target-SgNB-ID                                          CRITICALITY reject      TYPE GlobalGNB-ID                                               PRESENCE mandatory}|
61155         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
61156         { ID id-SgNBtoMeNBContainer                                     CRITICALITY reject      TYPE SgNBtoMeNBContainer                        PRESENCE optional}|
61157         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
61158         ...
61159 }
61160 */
61161
61162 struct SgNBChangeRequired_IEs
61163 {
61164         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61165         {
61166                 size_t get_index() const {return type;}
61167                 bool is_unknown() const { return type == 7; }
61168                 void clear() {type = 0;}
61169                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61170                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61171                 void select_id_Target_SgNB_ID() { set(id_Target_SgNB_ID); type=3;}
61172                 void select_id_Cause() { set(id_Cause); type=4;}
61173                 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=5;}
61174                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
61175                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61176                 template<typename V>  bool decode(V& v)
61177                 {
61178                         clear();
61179                         if(!v(ref_nested())) return false;
61180                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61181                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61182                         else if(equal(id_Target_SgNB_ID)) { type = 3; return true; }
61183                         else if(equal(id_Cause)) { type = 4; return true; }
61184                         else if(equal(id_SgNBtoMeNBContainer)) { type = 5; return true; }
61185                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
61186                         else { type = 7; return true;}
61187                         return false;
61188
61189                 }
61190                 template<typename V> bool encode(V& v) const
61191                 {
61192                         return v(ref_nested());
61193
61194                 }
61195                 protected:
61196                 template<typename V>  bool decode(size_t index, V& v)
61197                 {
61198                         clear();
61199                         switch(index)
61200                         {
61201                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61202                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61203                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Target_SgNB_ID);} return false;
61204                         case 4: type = 4; if(v(ref_nested())) { return equal(id_Cause);} return false;
61205                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
61206                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61207                         case 7: type = 7; return v(ref_nested());
61208                         ref_nested().clear();
61209                         }
61210                         return false;
61211
61212                 }
61213                 template<typename V> bool encode(size_t index, V& v) const
61214                 {
61215                         if(index != type) {return false;} return v(ref_nested());
61216
61217                 }
61218                 private:
61219                 size_t type {0};
61220
61221         };
61222         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61223         {
61224                 size_t get_index() const {return type;}
61225                 bool is_unknown() const { return type == 7; }
61226                 void clear() {type = 0;}
61227                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
61228                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
61229                 void select_id_Target_SgNB_ID() { set(reject); type=3;}
61230                 void select_id_Cause() { set(ignore); type=4;}
61231                 void select_id_SgNBtoMeNBContainer() { set(reject); type=5;}
61232                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
61233                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61234                 template<typename V>  bool decode(V& v)
61235                 {
61236                         clear();
61237                         if(!v(ref_nested())) return false;
61238                         if(equal(reject)) { type = 1; return true; }
61239                         else if(equal(reject)) { type = 2; return true; }
61240                         else if(equal(reject)) { type = 3; return true; }
61241                         else if(equal(ignore)) { type = 4; return true; }
61242                         else if(equal(reject)) { type = 5; return true; }
61243                         else if(equal(reject)) { type = 6; return true; }
61244                         else { type = 7; return true;}
61245                         return false;
61246
61247                 }
61248                 template<typename V> bool encode(V& v) const
61249                 {
61250                         return v(ref_nested());
61251
61252                 }
61253                 protected:
61254                 template<typename V>  bool decode(size_t index, V& v)
61255                 {
61256                         clear();
61257                         switch(index)
61258                         {
61259                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
61260                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
61261                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
61262                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61263                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
61264                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
61265                         case 7: type = 7; return v(ref_nested());
61266                         ref_nested().clear();
61267                         }
61268                         return false;
61269
61270                 }
61271                 template<typename V> bool encode(size_t index, V& v) const
61272                 {
61273                         if(index != type) {return false;} return v(ref_nested());
61274
61275                 }
61276                 private:
61277                 size_t type {0};
61278
61279         };
61280         struct Value_t : asn::typefield<true>
61281         {
61282                 ~Value_t()      {clear();}
61283                 size_t get_index() const {return type;}
61284                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61285                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61286                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61287                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61288                 GlobalGNB_ID& select_id_Target_SgNB_ID() { return set<GlobalGNB_ID>(3); }
61289                 GlobalGNB_ID const* get_id_Target_SgNB_ID() const { return get<GlobalGNB_ID>(3); }
61290                 Cause& select_id_Cause() { return set<Cause>(4); }
61291                 Cause const* get_id_Cause() const { return get<Cause>(4); }
61292                 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(5); }
61293                 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(5); }
61294                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
61295                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
61296                 bool is_unknown() const { return type == 7; }
61297                 void clear()
61298                 {
61299                         switch(type)
61300                         {
61301                         case 1: var.destroy<UE_X2AP_ID>(); break;
61302                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61303                         case 3: var.destroy<GlobalGNB_ID>(); break;
61304                         case 4: var.destroy<Cause>(); break;
61305                         case 5: var.destroy<SgNBtoMeNBContainer>(); break;
61306                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
61307                         }
61308                         type = 0; ref_nested().clear();
61309                 }
61310                 template<typename V> static inline void enumerate(V& v)
61311                 {
61312                         v.template operator()<UE_X2AP_ID>(1);
61313                         v.template operator()<SgNB_UE_X2AP_ID>(2);
61314                         v.template operator()<GlobalGNB_ID>(3);
61315                         v.template operator()<Cause>(4);
61316                         v.template operator()<SgNBtoMeNBContainer>(5);
61317                         v.template operator()<UE_X2AP_ID_Extension>(6);
61318
61319                 }
61320                 protected:
61321                 template<typename V> bool decode(size_t index, V& v)
61322                 {
61323                         clear();
61324                         switch(index)
61325                         {
61326                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61327                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61328                         case 3: v(select_id_Target_SgNB_ID()); return true;
61329                         case 4: v(select_id_Cause()); return true;
61330                         case 5: v(select_id_SgNBtoMeNBContainer()); return true;
61331                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61332                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
61333                         }
61334                         return false;
61335
61336                 }
61337                 template<typename V> bool encode(size_t index, V& v) const
61338                 {
61339                         if(index != type) return false;
61340                         switch(type)
61341                         {
61342                         case 1: v(var.as<UE_X2AP_ID>()); return true;
61343                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61344                         case 3: v(var.as<GlobalGNB_ID>()); return true;
61345                         case 4: v(var.as<Cause>()); return true;
61346                         case 5: v(var.as<SgNBtoMeNBContainer>()); return true;
61347                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
61348                         }
61349                         return false;
61350
61351                 }
61352                 private:
61353                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61354                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61355                 union union_type
61356                 {
61357                         char dummy1[sizeof(Cause)];
61358                         char dummy2[sizeof(GlobalGNB_ID)];
61359                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
61360                         char dummy4[sizeof(SgNBtoMeNBContainer)];
61361                         char dummy5[sizeof(UE_X2AP_ID)];
61362                         char dummy6[sizeof(UE_X2AP_ID_Extension)];
61363
61364                 };
61365                 asn::variant<sizeof(union_type)> var;
61366                 size_t type {0};
61367
61368         };
61369         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61370         {
61371                 size_t get_index() const {return type;}
61372                 bool is_unknown() const { return type == 7; }
61373                 void clear() {type = 0;}
61374                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61375                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61376                 void select_id_Target_SgNB_ID() { set(mandatory); type=3;}
61377                 void select_id_Cause() { set(mandatory); type=4;}
61378                 void select_id_SgNBtoMeNBContainer() { set(optional); type=5;}
61379                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
61380                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61381                 template<typename V>  bool decode(V& v)
61382                 {
61383                         clear();
61384                         if(!v(ref_nested())) return false;
61385                         if(equal(mandatory)) { type = 1; return true; }
61386                         else if(equal(mandatory)) { type = 2; return true; }
61387                         else if(equal(mandatory)) { type = 3; return true; }
61388                         else if(equal(mandatory)) { type = 4; return true; }
61389                         else if(equal(optional)) { type = 5; return true; }
61390                         else if(equal(optional)) { type = 6; return true; }
61391                         else { type = 7; return true;}
61392                         return false;
61393
61394                 }
61395                 template<typename V> bool encode(V& v) const
61396                 {
61397                         return v(ref_nested());
61398
61399                 }
61400                 protected:
61401                 template<typename V>  bool decode(size_t index, V& v)
61402                 {
61403                         clear();
61404                         switch(index)
61405                         {
61406                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61407                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61408                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61409                         case 4: type = 4; if(v(ref_nested())) { return equal(mandatory);} return false;
61410                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
61411                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
61412                         case 7: type = 7; return v(ref_nested());
61413                         ref_nested().clear();
61414                         }
61415                         return false;
61416
61417                 }
61418                 template<typename V> bool encode(size_t index, V& v) const
61419                 {
61420                         if(index != type) {return false;} return v(ref_nested());
61421
61422                 }
61423                 private:
61424                 size_t type {0};
61425
61426         };
61427
61428 };
61429 /*
61430 SgNBChangeRequired ::= SEQUENCE {
61431         protocolIEs             ProtocolIE-Container            {{SgNBChangeRequired-IEs}},
61432         ...
61433 }
61434 */
61435
61436 struct SgNBChangeRequired : asn::sequence<1, 0, true, 0>
61437 {
61438         static constexpr const char* name() {return "SgNBChangeRequired";}
61439         using parent_t = asn::sequence<1, 0, true, 0>;
61440         struct protocolIEs_t : ProtocolIE_Container<SgNBChangeRequired_IEs>
61441         {
61442                 static constexpr const char* name() {return "protocolIEs_t";}
61443                 using parent_t = ProtocolIE_Container<SgNBChangeRequired_IEs>;
61444
61445         };
61446         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61447         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61448         template<typename V> void decode(V& v)
61449         {
61450                 v(protocolIEs);
61451
61452         };
61453         template<typename V> void encode(V& v) const
61454         {
61455                 v(protocolIEs);
61456
61457         };
61458         void clear()
61459         {
61460                 protocolIEs.clear();
61461
61462         };
61463         private:
61464         protocolIEs_t   protocolIEs;
61465
61466 };
61467 /*
61468 SgNBCounterCheckRequest-IEs X2AP-PROTOCOL-IES ::= {
61469         { ID id-MeNB-UE-X2AP-ID                                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
61470         { ID id-SgNB-UE-X2AP-ID                                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                            PRESENCE mandatory}|
61471         { ID id-E-RABs-SubjectToSgNBCounterCheck-List           CRITICALITY ignore      TYPE E-RABs-SubjectToSgNBCounterCheck-List              PRESENCE mandatory}|
61472         { ID id-MeNB-UE-X2AP-ID-Extension                                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional},
61473         ...
61474 }
61475 */
61476
61477 struct SgNBCounterCheckRequest_IEs
61478 {
61479         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61480         {
61481                 size_t get_index() const {return type;}
61482                 bool is_unknown() const { return type == 5; }
61483                 void clear() {type = 0;}
61484                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61485                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61486                 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(id_E_RABs_SubjectToSgNBCounterCheck_List); type=3;}
61487                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
61488                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61489                 template<typename V>  bool decode(V& v)
61490                 {
61491                         clear();
61492                         if(!v(ref_nested())) return false;
61493                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61494                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61495                         else if(equal(id_E_RABs_SubjectToSgNBCounterCheck_List)) { type = 3; return true; }
61496                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
61497                         else { type = 5; return true;}
61498                         return false;
61499
61500                 }
61501                 template<typename V> bool encode(V& v) const
61502                 {
61503                         return v(ref_nested());
61504
61505                 }
61506                 protected:
61507                 template<typename V>  bool decode(size_t index, V& v)
61508                 {
61509                         clear();
61510                         switch(index)
61511                         {
61512                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61513                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61514                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_SubjectToSgNBCounterCheck_List);} return false;
61515                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61516                         case 5: type = 5; return v(ref_nested());
61517                         ref_nested().clear();
61518                         }
61519                         return false;
61520
61521                 }
61522                 template<typename V> bool encode(size_t index, V& v) const
61523                 {
61524                         if(index != type) {return false;} return v(ref_nested());
61525
61526                 }
61527                 private:
61528                 size_t type {0};
61529
61530         };
61531         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61532         {
61533                 size_t get_index() const {return type;}
61534                 bool is_unknown() const { return type == 5; }
61535                 void clear() {type = 0;}
61536                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
61537                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
61538                 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(ignore); type=3;}
61539                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=4;}
61540                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61541                 template<typename V>  bool decode(V& v)
61542                 {
61543                         clear();
61544                         if(!v(ref_nested())) return false;
61545                         if(equal(reject)) { type = 1; return true; }
61546                         else if(equal(reject)) { type = 2; return true; }
61547                         else if(equal(ignore)) { type = 3; return true; }
61548                         else if(equal(ignore)) { type = 4; return true; }
61549                         else { type = 5; return true;}
61550                         return false;
61551
61552                 }
61553                 template<typename V> bool encode(V& v) const
61554                 {
61555                         return v(ref_nested());
61556
61557                 }
61558                 protected:
61559                 template<typename V>  bool decode(size_t index, V& v)
61560                 {
61561                         clear();
61562                         switch(index)
61563                         {
61564                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
61565                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
61566                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
61567                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61568                         case 5: type = 5; return v(ref_nested());
61569                         ref_nested().clear();
61570                         }
61571                         return false;
61572
61573                 }
61574                 template<typename V> bool encode(size_t index, V& v) const
61575                 {
61576                         if(index != type) {return false;} return v(ref_nested());
61577
61578                 }
61579                 private:
61580                 size_t type {0};
61581
61582         };
61583         struct Value_t : asn::typefield<true>
61584         {
61585                 ~Value_t()      {clear();}
61586                 size_t get_index() const {return type;}
61587                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61588                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61589                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61590                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61591                 E_RABs_SubjectToSgNBCounterCheck_List& select_id_E_RABs_SubjectToSgNBCounterCheck_List() { return set<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
61592                 E_RABs_SubjectToSgNBCounterCheck_List const* get_id_E_RABs_SubjectToSgNBCounterCheck_List() const { return get<E_RABs_SubjectToSgNBCounterCheck_List>(3); }
61593                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
61594                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
61595                 bool is_unknown() const { return type == 5; }
61596                 void clear()
61597                 {
61598                         switch(type)
61599                         {
61600                         case 1: var.destroy<UE_X2AP_ID>(); break;
61601                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61602                         case 3: var.destroy<E_RABs_SubjectToSgNBCounterCheck_List>(); break;
61603                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
61604                         }
61605                         type = 0; ref_nested().clear();
61606                 }
61607                 template<typename V> static inline void enumerate(V& v)
61608                 {
61609                         v.template operator()<UE_X2AP_ID>(1);
61610                         v.template operator()<SgNB_UE_X2AP_ID>(2);
61611                         v.template operator()<E_RABs_SubjectToSgNBCounterCheck_List>(3);
61612                         v.template operator()<UE_X2AP_ID_Extension>(4);
61613
61614                 }
61615                 protected:
61616                 template<typename V> bool decode(size_t index, V& v)
61617                 {
61618                         clear();
61619                         switch(index)
61620                         {
61621                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61622                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61623                         case 3: v(select_id_E_RABs_SubjectToSgNBCounterCheck_List()); return true;
61624                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61625                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
61626                         }
61627                         return false;
61628
61629                 }
61630                 template<typename V> bool encode(size_t index, V& v) const
61631                 {
61632                         if(index != type) return false;
61633                         switch(type)
61634                         {
61635                         case 1: v(var.as<UE_X2AP_ID>()); return true;
61636                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61637                         case 3: v(var.as<E_RABs_SubjectToSgNBCounterCheck_List>()); return true;
61638                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
61639                         }
61640                         return false;
61641
61642                 }
61643                 private:
61644                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61645                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61646                 union union_type
61647                 {
61648                         char dummy1[sizeof(E_RABs_SubjectToSgNBCounterCheck_List)];
61649                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
61650                         char dummy3[sizeof(UE_X2AP_ID)];
61651                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
61652
61653                 };
61654                 asn::variant<sizeof(union_type)> var;
61655                 size_t type {0};
61656
61657         };
61658         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61659         {
61660                 size_t get_index() const {return type;}
61661                 bool is_unknown() const { return type == 5; }
61662                 void clear() {type = 0;}
61663                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61664                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61665                 void select_id_E_RABs_SubjectToSgNBCounterCheck_List() { set(mandatory); type=3;}
61666                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
61667                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61668                 template<typename V>  bool decode(V& v)
61669                 {
61670                         clear();
61671                         if(!v(ref_nested())) return false;
61672                         if(equal(mandatory)) { type = 1; return true; }
61673                         else if(equal(mandatory)) { type = 2; return true; }
61674                         else if(equal(mandatory)) { type = 3; return true; }
61675                         else if(equal(optional)) { type = 4; return true; }
61676                         else { type = 5; return true;}
61677                         return false;
61678
61679                 }
61680                 template<typename V> bool encode(V& v) const
61681                 {
61682                         return v(ref_nested());
61683
61684                 }
61685                 protected:
61686                 template<typename V>  bool decode(size_t index, V& v)
61687                 {
61688                         clear();
61689                         switch(index)
61690                         {
61691                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
61692                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
61693                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
61694                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
61695                         case 5: type = 5; return v(ref_nested());
61696                         ref_nested().clear();
61697                         }
61698                         return false;
61699
61700                 }
61701                 template<typename V> bool encode(size_t index, V& v) const
61702                 {
61703                         if(index != type) {return false;} return v(ref_nested());
61704
61705                 }
61706                 private:
61707                 size_t type {0};
61708
61709         };
61710
61711 };
61712 /*
61713 SgNBCounterCheckRequest ::= SEQUENCE {
61714         protocolIEs             ProtocolIE-Container    {{SgNBCounterCheckRequest-IEs}},
61715         ...
61716 }
61717 */
61718
61719 struct SgNBCounterCheckRequest : asn::sequence<1, 0, true, 0>
61720 {
61721         static constexpr const char* name() {return "SgNBCounterCheckRequest";}
61722         using parent_t = asn::sequence<1, 0, true, 0>;
61723         struct protocolIEs_t : ProtocolIE_Container<SgNBCounterCheckRequest_IEs>
61724         {
61725                 static constexpr const char* name() {return "protocolIEs_t";}
61726                 using parent_t = ProtocolIE_Container<SgNBCounterCheckRequest_IEs>;
61727
61728         };
61729         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
61730         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
61731         template<typename V> void decode(V& v)
61732         {
61733                 v(protocolIEs);
61734
61735         };
61736         template<typename V> void encode(V& v) const
61737         {
61738                 v(protocolIEs);
61739
61740         };
61741         void clear()
61742         {
61743                 protocolIEs.clear();
61744
61745         };
61746         private:
61747         protocolIEs_t   protocolIEs;
61748
61749 };
61750 /*
61751 SgNBModificationConfirm-IEs X2AP-PROTOCOL-IES ::= {
61752         { ID id-MeNB-UE-X2AP-ID                                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
61753         { ID id-SgNB-UE-X2AP-ID                                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE mandatory}|
61754         { ID id-E-RABs-AdmittedToBeModified-SgNBModConfList             CRITICALITY ignore      TYPE E-RABs-AdmittedToBeModified-SgNBModConfList                PRESENCE optional}|
61755         { ID id-MeNBtoSgNBContainer                                                             CRITICALITY ignore      TYPE MeNBtoSgNBContainer                                                        PRESENCE optional}|
61756         { ID id-CriticalityDiagnostics                                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional}|
61757         { ID id-MeNB-UE-X2AP-ID-Extension                                               CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
61758         { ID id-MeNBResourceCoordinationInformation                             CRITICALITY ignore      TYPE MeNBResourceCoordinationInformation                PRESENCE optional},
61759         ...
61760 }
61761 */
61762
61763 struct SgNBModificationConfirm_IEs
61764 {
61765         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
61766         {
61767                 size_t get_index() const {return type;}
61768                 bool is_unknown() const { return type == 8; }
61769                 void clear() {type = 0;}
61770                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
61771                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
61772                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(id_E_RABs_AdmittedToBeModified_SgNBModConfList); type=3;}
61773                 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
61774                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
61775                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
61776                 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=7;}
61777                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
61778                 template<typename V>  bool decode(V& v)
61779                 {
61780                         clear();
61781                         if(!v(ref_nested())) return false;
61782                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
61783                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
61784                         else if(equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList)) { type = 3; return true; }
61785                         else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
61786                         else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
61787                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
61788                         else if(equal(id_MeNBResourceCoordinationInformation)) { type = 7; return true; }
61789                         else { type = 8; return true;}
61790                         return false;
61791
61792                 }
61793                 template<typename V> bool encode(V& v) const
61794                 {
61795                         return v(ref_nested());
61796
61797                 }
61798                 protected:
61799                 template<typename V>  bool decode(size_t index, V& v)
61800                 {
61801                         clear();
61802                         switch(index)
61803                         {
61804                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
61805                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
61806                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_AdmittedToBeModified_SgNBModConfList);} return false;
61807                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
61808                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
61809                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
61810                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
61811                         case 8: type = 8; return v(ref_nested());
61812                         ref_nested().clear();
61813                         }
61814                         return false;
61815
61816                 }
61817                 template<typename V> bool encode(size_t index, V& v) const
61818                 {
61819                         if(index != type) {return false;} return v(ref_nested());
61820
61821                 }
61822                 private:
61823                 size_t type {0};
61824
61825         };
61826         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
61827         {
61828                 size_t get_index() const {return type;}
61829                 bool is_unknown() const { return type == 8; }
61830                 void clear() {type = 0;}
61831                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
61832                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
61833                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(ignore); type=3;}
61834                 void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
61835                 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
61836                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
61837                 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=7;}
61838                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
61839                 template<typename V>  bool decode(V& v)
61840                 {
61841                         clear();
61842                         if(!v(ref_nested())) return false;
61843                         if(equal(ignore)) { type = 1; return true; }
61844                         else if(equal(ignore)) { type = 2; return true; }
61845                         else if(equal(ignore)) { type = 3; return true; }
61846                         else if(equal(ignore)) { type = 4; return true; }
61847                         else if(equal(ignore)) { type = 5; return true; }
61848                         else if(equal(ignore)) { type = 6; return true; }
61849                         else if(equal(ignore)) { type = 7; return true; }
61850                         else { type = 8; return true;}
61851                         return false;
61852
61853                 }
61854                 template<typename V> bool encode(V& v) const
61855                 {
61856                         return v(ref_nested());
61857
61858                 }
61859                 protected:
61860                 template<typename V>  bool decode(size_t index, V& v)
61861                 {
61862                         clear();
61863                         switch(index)
61864                         {
61865                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
61866                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
61867                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
61868                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
61869                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
61870                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
61871                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
61872                         case 8: type = 8; return v(ref_nested());
61873                         ref_nested().clear();
61874                         }
61875                         return false;
61876
61877                 }
61878                 template<typename V> bool encode(size_t index, V& v) const
61879                 {
61880                         if(index != type) {return false;} return v(ref_nested());
61881
61882                 }
61883                 private:
61884                 size_t type {0};
61885
61886         };
61887         struct Value_t : asn::typefield<true>
61888         {
61889                 ~Value_t()      {clear();}
61890                 size_t get_index() const {return type;}
61891                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
61892                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
61893                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
61894                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
61895                 E_RABs_AdmittedToBeModified_SgNBModConfList& select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { return set<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
61896                 E_RABs_AdmittedToBeModified_SgNBModConfList const* get_id_E_RABs_AdmittedToBeModified_SgNBModConfList() const { return get<E_RABs_AdmittedToBeModified_SgNBModConfList>(3); }
61897                 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
61898                 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
61899                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
61900                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
61901                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
61902                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
61903                 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(7); }
61904                 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(7); }
61905                 bool is_unknown() const { return type == 8; }
61906                 void clear()
61907                 {
61908                         switch(type)
61909                         {
61910                         case 1: var.destroy<UE_X2AP_ID>(); break;
61911                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
61912                         case 3: var.destroy<E_RABs_AdmittedToBeModified_SgNBModConfList>(); break;
61913                         case 4: var.destroy<MeNBtoSgNBContainer>(); break;
61914                         case 5: var.destroy<CriticalityDiagnostics>(); break;
61915                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
61916                         case 7: var.destroy<MeNBResourceCoordinationInformation>(); break;
61917                         }
61918                         type = 0; ref_nested().clear();
61919                 }
61920                 template<typename V> static inline void enumerate(V& v)
61921                 {
61922                         v.template operator()<UE_X2AP_ID>(1);
61923                         v.template operator()<SgNB_UE_X2AP_ID>(2);
61924                         v.template operator()<E_RABs_AdmittedToBeModified_SgNBModConfList>(3);
61925                         v.template operator()<MeNBtoSgNBContainer>(4);
61926                         v.template operator()<CriticalityDiagnostics>(5);
61927                         v.template operator()<UE_X2AP_ID_Extension>(6);
61928                         v.template operator()<MeNBResourceCoordinationInformation>(7);
61929
61930                 }
61931                 protected:
61932                 template<typename V> bool decode(size_t index, V& v)
61933                 {
61934                         clear();
61935                         switch(index)
61936                         {
61937                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
61938                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
61939                         case 3: v(select_id_E_RABs_AdmittedToBeModified_SgNBModConfList()); return true;
61940                         case 4: v(select_id_MeNBtoSgNBContainer()); return true;
61941                         case 5: v(select_id_CriticalityDiagnostics()); return true;
61942                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
61943                         case 7: v(select_id_MeNBResourceCoordinationInformation()); return true;
61944                         case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
61945                         }
61946                         return false;
61947
61948                 }
61949                 template<typename V> bool encode(size_t index, V& v) const
61950                 {
61951                         if(index != type) return false;
61952                         switch(type)
61953                         {
61954                         case 1: v(var.as<UE_X2AP_ID>()); return true;
61955                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
61956                         case 3: v(var.as<E_RABs_AdmittedToBeModified_SgNBModConfList>()); return true;
61957                         case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
61958                         case 5: v(var.as<CriticalityDiagnostics>()); return true;
61959                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
61960                         case 7: v(var.as<MeNBResourceCoordinationInformation>()); return true;
61961                         }
61962                         return false;
61963
61964                 }
61965                 private:
61966                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
61967                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
61968                 union union_type
61969                 {
61970                         char dummy1[sizeof(CriticalityDiagnostics)];
61971                         char dummy2[sizeof(E_RABs_AdmittedToBeModified_SgNBModConfList)];
61972                         char dummy3[sizeof(MeNBResourceCoordinationInformation)];
61973                         char dummy4[sizeof(MeNBtoSgNBContainer)];
61974                         char dummy5[sizeof(SgNB_UE_X2AP_ID)];
61975                         char dummy6[sizeof(UE_X2AP_ID)];
61976                         char dummy7[sizeof(UE_X2AP_ID_Extension)];
61977
61978                 };
61979                 asn::variant<sizeof(union_type)> var;
61980                 size_t type {0};
61981
61982         };
61983         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
61984         {
61985                 size_t get_index() const {return type;}
61986                 bool is_unknown() const { return type == 8; }
61987                 void clear() {type = 0;}
61988                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
61989                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
61990                 void select_id_E_RABs_AdmittedToBeModified_SgNBModConfList() { set(optional); type=3;}
61991                 void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
61992                 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
61993                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
61994                 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=7;}
61995                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
61996                 template<typename V>  bool decode(V& v)
61997                 {
61998                         clear();
61999                         if(!v(ref_nested())) return false;
62000                         if(equal(mandatory)) { type = 1; return true; }
62001                         else if(equal(mandatory)) { type = 2; return true; }
62002                         else if(equal(optional)) { type = 3; return true; }
62003                         else if(equal(optional)) { type = 4; return true; }
62004                         else if(equal(optional)) { type = 5; return true; }
62005                         else if(equal(optional)) { type = 6; return true; }
62006                         else if(equal(optional)) { type = 7; return true; }
62007                         else { type = 8; return true;}
62008                         return false;
62009
62010                 }
62011                 template<typename V> bool encode(V& v) const
62012                 {
62013                         return v(ref_nested());
62014
62015                 }
62016                 protected:
62017                 template<typename V>  bool decode(size_t index, V& v)
62018                 {
62019                         clear();
62020                         switch(index)
62021                         {
62022                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
62023                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
62024                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
62025                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
62026                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
62027                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
62028                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
62029                         case 8: type = 8; return v(ref_nested());
62030                         ref_nested().clear();
62031                         }
62032                         return false;
62033
62034                 }
62035                 template<typename V> bool encode(size_t index, V& v) const
62036                 {
62037                         if(index != type) {return false;} return v(ref_nested());
62038
62039                 }
62040                 private:
62041                 size_t type {0};
62042
62043         };
62044
62045 };
62046 /*
62047 SgNBModificationConfirm ::= SEQUENCE {
62048         protocolIEs             ProtocolIE-Container    {{SgNBModificationConfirm-IEs}},
62049         ...
62050 }
62051 */
62052
62053 struct SgNBModificationConfirm : asn::sequence<1, 0, true, 0>
62054 {
62055         static constexpr const char* name() {return "SgNBModificationConfirm";}
62056         using parent_t = asn::sequence<1, 0, true, 0>;
62057         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationConfirm_IEs>
62058         {
62059                 static constexpr const char* name() {return "protocolIEs_t";}
62060                 using parent_t = ProtocolIE_Container<SgNBModificationConfirm_IEs>;
62061
62062         };
62063         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
62064         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
62065         template<typename V> void decode(V& v)
62066         {
62067                 v(protocolIEs);
62068
62069         };
62070         template<typename V> void encode(V& v) const
62071         {
62072                 v(protocolIEs);
62073
62074         };
62075         void clear()
62076         {
62077                 protocolIEs.clear();
62078
62079         };
62080         private:
62081         protocolIEs_t   protocolIEs;
62082
62083 };
62084 /*
62085 SgNBModificationRefuse-IEs X2AP-PROTOCOL-IES ::= {
62086         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
62087         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                            PRESENCE mandatory}|
62088         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
62089         { ID id-MeNBtoSgNBContainer                                     CRITICALITY ignore      TYPE MeNBtoSgNBContainer                        PRESENCE optional}|
62090         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
62091         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
62092         ...
62093 }
62094 */
62095
62096 struct SgNBModificationRefuse_IEs
62097 {
62098         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
62099         {
62100                 size_t get_index() const {return type;}
62101                 bool is_unknown() const { return type == 7; }
62102                 void clear() {type = 0;}
62103                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
62104                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
62105                 void select_id_Cause() { set(id_Cause); type=3;}
62106                 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=4;}
62107                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=5;}
62108                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
62109                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
62110                 template<typename V>  bool decode(V& v)
62111                 {
62112                         clear();
62113                         if(!v(ref_nested())) return false;
62114                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
62115                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
62116                         else if(equal(id_Cause)) { type = 3; return true; }
62117                         else if(equal(id_MeNBtoSgNBContainer)) { type = 4; return true; }
62118                         else if(equal(id_CriticalityDiagnostics)) { type = 5; return true; }
62119                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
62120                         else { type = 7; return true;}
62121                         return false;
62122
62123                 }
62124                 template<typename V> bool encode(V& v) const
62125                 {
62126                         return v(ref_nested());
62127
62128                 }
62129                 protected:
62130                 template<typename V>  bool decode(size_t index, V& v)
62131                 {
62132                         clear();
62133                         switch(index)
62134                         {
62135                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
62136                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
62137                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
62138                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
62139                         case 5: type = 5; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
62140                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
62141                         case 7: type = 7; return v(ref_nested());
62142                         ref_nested().clear();
62143                         }
62144                         return false;
62145
62146                 }
62147                 template<typename V> bool encode(size_t index, V& v) const
62148                 {
62149                         if(index != type) {return false;} return v(ref_nested());
62150
62151                 }
62152                 private:
62153                 size_t type {0};
62154
62155         };
62156         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
62157         {
62158                 size_t get_index() const {return type;}
62159                 bool is_unknown() const { return type == 7; }
62160                 void clear() {type = 0;}
62161                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
62162                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
62163                 void select_id_Cause() { set(ignore); type=3;}
62164                 void select_id_MeNBtoSgNBContainer() { set(ignore); type=4;}
62165                 void select_id_CriticalityDiagnostics() { set(ignore); type=5;}
62166                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=6;}
62167                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
62168                 template<typename V>  bool decode(V& v)
62169                 {
62170                         clear();
62171                         if(!v(ref_nested())) return false;
62172                         if(equal(ignore)) { type = 1; return true; }
62173                         else if(equal(ignore)) { type = 2; return true; }
62174                         else if(equal(ignore)) { type = 3; return true; }
62175                         else if(equal(ignore)) { type = 4; return true; }
62176                         else if(equal(ignore)) { type = 5; return true; }
62177                         else if(equal(ignore)) { type = 6; return true; }
62178                         else { type = 7; return true;}
62179                         return false;
62180
62181                 }
62182                 template<typename V> bool encode(V& v) const
62183                 {
62184                         return v(ref_nested());
62185
62186                 }
62187                 protected:
62188                 template<typename V>  bool decode(size_t index, V& v)
62189                 {
62190                         clear();
62191                         switch(index)
62192                         {
62193                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
62194                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
62195                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
62196                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
62197                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
62198                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
62199                         case 7: type = 7; return v(ref_nested());
62200                         ref_nested().clear();
62201                         }
62202                         return false;
62203
62204                 }
62205                 template<typename V> bool encode(size_t index, V& v) const
62206                 {
62207                         if(index != type) {return false;} return v(ref_nested());
62208
62209                 }
62210                 private:
62211                 size_t type {0};
62212
62213         };
62214         struct Value_t : asn::typefield<true>
62215         {
62216                 ~Value_t()      {clear();}
62217                 size_t get_index() const {return type;}
62218                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
62219                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
62220                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
62221                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
62222                 Cause& select_id_Cause() { return set<Cause>(3); }
62223                 Cause const* get_id_Cause() const { return get<Cause>(3); }
62224                 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(4); }
62225                 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(4); }
62226                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(5); }
62227                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(5); }
62228                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
62229                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
62230                 bool is_unknown() const { return type == 7; }
62231                 void clear()
62232                 {
62233                         switch(type)
62234                         {
62235                         case 1: var.destroy<UE_X2AP_ID>(); break;
62236                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
62237                         case 3: var.destroy<Cause>(); break;
62238                         case 4: var.destroy<MeNBtoSgNBContainer>(); break;
62239                         case 5: var.destroy<CriticalityDiagnostics>(); break;
62240                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
62241                         }
62242                         type = 0; ref_nested().clear();
62243                 }
62244                 template<typename V> static inline void enumerate(V& v)
62245                 {
62246                         v.template operator()<UE_X2AP_ID>(1);
62247                         v.template operator()<SgNB_UE_X2AP_ID>(2);
62248                         v.template operator()<Cause>(3);
62249                         v.template operator()<MeNBtoSgNBContainer>(4);
62250                         v.template operator()<CriticalityDiagnostics>(5);
62251                         v.template operator()<UE_X2AP_ID_Extension>(6);
62252
62253                 }
62254                 protected:
62255                 template<typename V> bool decode(size_t index, V& v)
62256                 {
62257                         clear();
62258                         switch(index)
62259                         {
62260                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
62261                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
62262                         case 3: v(select_id_Cause()); return true;
62263                         case 4: v(select_id_MeNBtoSgNBContainer()); return true;
62264                         case 5: v(select_id_CriticalityDiagnostics()); return true;
62265                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
62266                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
62267                         }
62268                         return false;
62269
62270                 }
62271                 template<typename V> bool encode(size_t index, V& v) const
62272                 {
62273                         if(index != type) return false;
62274                         switch(type)
62275                         {
62276                         case 1: v(var.as<UE_X2AP_ID>()); return true;
62277                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
62278                         case 3: v(var.as<Cause>()); return true;
62279                         case 4: v(var.as<MeNBtoSgNBContainer>()); return true;
62280                         case 5: v(var.as<CriticalityDiagnostics>()); return true;
62281                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
62282                         }
62283                         return false;
62284
62285                 }
62286                 private:
62287                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
62288                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
62289                 union union_type
62290                 {
62291                         char dummy1[sizeof(Cause)];
62292                         char dummy2[sizeof(CriticalityDiagnostics)];
62293                         char dummy3[sizeof(MeNBtoSgNBContainer)];
62294                         char dummy4[sizeof(SgNB_UE_X2AP_ID)];
62295                         char dummy5[sizeof(UE_X2AP_ID)];
62296                         char dummy6[sizeof(UE_X2AP_ID_Extension)];
62297
62298                 };
62299                 asn::variant<sizeof(union_type)> var;
62300                 size_t type {0};
62301
62302         };
62303         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
62304         {
62305                 size_t get_index() const {return type;}
62306                 bool is_unknown() const { return type == 7; }
62307                 void clear() {type = 0;}
62308                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
62309                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
62310                 void select_id_Cause() { set(mandatory); type=3;}
62311                 void select_id_MeNBtoSgNBContainer() { set(optional); type=4;}
62312                 void select_id_CriticalityDiagnostics() { set(optional); type=5;}
62313                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
62314                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
62315                 template<typename V>  bool decode(V& v)
62316                 {
62317                         clear();
62318                         if(!v(ref_nested())) return false;
62319                         if(equal(mandatory)) { type = 1; return true; }
62320                         else if(equal(mandatory)) { type = 2; return true; }
62321                         else if(equal(mandatory)) { type = 3; return true; }
62322                         else if(equal(optional)) { type = 4; return true; }
62323                         else if(equal(optional)) { type = 5; return true; }
62324                         else if(equal(optional)) { type = 6; return true; }
62325                         else { type = 7; return true;}
62326                         return false;
62327
62328                 }
62329                 template<typename V> bool encode(V& v) const
62330                 {
62331                         return v(ref_nested());
62332
62333                 }
62334                 protected:
62335                 template<typename V>  bool decode(size_t index, V& v)
62336                 {
62337                         clear();
62338                         switch(index)
62339                         {
62340                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
62341                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
62342                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
62343                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
62344                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
62345                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
62346                         case 7: type = 7; return v(ref_nested());
62347                         ref_nested().clear();
62348                         }
62349                         return false;
62350
62351                 }
62352                 template<typename V> bool encode(size_t index, V& v) const
62353                 {
62354                         if(index != type) {return false;} return v(ref_nested());
62355
62356                 }
62357                 private:
62358                 size_t type {0};
62359
62360         };
62361
62362 };
62363 /*
62364 SgNBModificationRefuse ::= SEQUENCE {
62365         protocolIEs             ProtocolIE-Container            {{SgNBModificationRefuse-IEs}},
62366         ...
62367 }
62368 */
62369
62370 struct SgNBModificationRefuse : asn::sequence<1, 0, true, 0>
62371 {
62372         static constexpr const char* name() {return "SgNBModificationRefuse";}
62373         using parent_t = asn::sequence<1, 0, true, 0>;
62374         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRefuse_IEs>
62375         {
62376                 static constexpr const char* name() {return "protocolIEs_t";}
62377                 using parent_t = ProtocolIE_Container<SgNBModificationRefuse_IEs>;
62378
62379         };
62380         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
62381         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
62382         template<typename V> void decode(V& v)
62383         {
62384                 v(protocolIEs);
62385
62386         };
62387         template<typename V> void encode(V& v) const
62388         {
62389                 v(protocolIEs);
62390
62391         };
62392         void clear()
62393         {
62394                 protocolIEs.clear();
62395
62396         };
62397         private:
62398         protocolIEs_t   protocolIEs;
62399
62400 };
62401 /*
62402 UE-ContextInformationSgNBModReqExtIEs X2AP-PROTOCOL-EXTENSION ::= {
62403         {       ID id-SubscriberProfileIDforRFP                                 CRITICALITY ignore      EXTENSION SubscriberProfileIDforRFP                                                                     PRESENCE optional},
62404         ...
62405 }
62406 */
62407
62408 struct UE_ContextInformationSgNBModReqExtIEs
62409 {
62410         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
62411         {
62412                 size_t get_index() const {return type;}
62413                 bool is_unknown() const { return type == 2; }
62414                 void clear() {type = 0;}
62415                 void select_id_SubscriberProfileIDforRFP() { set(id_SubscriberProfileIDforRFP); type=1;}
62416                 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
62417                 template<typename V>  bool decode(V& v)
62418                 {
62419                         clear();
62420                         if(!v(ref_nested())) return false;
62421                         if(equal(id_SubscriberProfileIDforRFP)) { type = 1; return true; }
62422                         else { type = 2; return true;}
62423                         return false;
62424
62425                 }
62426                 template<typename V> bool encode(V& v) const
62427                 {
62428                         return v(ref_nested());
62429
62430                 }
62431                 protected:
62432                 template<typename V>  bool decode(size_t index, V& v)
62433                 {
62434                         clear();
62435                         switch(index)
62436                         {
62437                         case 1: type = 1; if(v(ref_nested())) { return equal(id_SubscriberProfileIDforRFP);} return false;
62438                         case 2: type = 2; return v(ref_nested());
62439                         ref_nested().clear();
62440                         }
62441                         return false;
62442
62443                 }
62444                 template<typename V> bool encode(size_t index, V& v) const
62445                 {
62446                         if(index != type) {return false;} return v(ref_nested());
62447
62448                 }
62449                 private:
62450                 size_t type {0};
62451
62452         };
62453         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
62454         {
62455                 size_t get_index() const {return type;}
62456                 bool is_unknown() const { return type == 2; }
62457                 void clear() {type = 0;}
62458                 void select_id_SubscriberProfileIDforRFP() { set(ignore); type=1;}
62459                 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
62460                 template<typename V>  bool decode(V& v)
62461                 {
62462                         clear();
62463                         if(!v(ref_nested())) return false;
62464                         if(equal(ignore)) { type = 1; return true; }
62465                         else { type = 2; return true;}
62466                         return false;
62467
62468                 }
62469                 template<typename V> bool encode(V& v) const
62470                 {
62471                         return v(ref_nested());
62472
62473                 }
62474                 protected:
62475                 template<typename V>  bool decode(size_t index, V& v)
62476                 {
62477                         clear();
62478                         switch(index)
62479                         {
62480                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
62481                         case 2: type = 2; return v(ref_nested());
62482                         ref_nested().clear();
62483                         }
62484                         return false;
62485
62486                 }
62487                 template<typename V> bool encode(size_t index, V& v) const
62488                 {
62489                         if(index != type) {return false;} return v(ref_nested());
62490
62491                 }
62492                 private:
62493                 size_t type {0};
62494
62495         };
62496         struct Extension_t : asn::typefield<true>
62497         {
62498                 ~Extension_t()  {clear();}
62499                 size_t get_index() const {return type;}
62500                 SubscriberProfileIDforRFP& select_id_SubscriberProfileIDforRFP() { return set<SubscriberProfileIDforRFP>(1); }
62501                 SubscriberProfileIDforRFP const* get_id_SubscriberProfileIDforRFP() const { return get<SubscriberProfileIDforRFP>(1); }
62502                 bool is_unknown() const { return type == 2; }
62503                 void clear()
62504                 {
62505                         switch(type)
62506                         {
62507                         case 1: var.destroy<SubscriberProfileIDforRFP>(); break;
62508                         }
62509                         type = 0; ref_nested().clear();
62510                 }
62511                 template<typename V> static inline void enumerate(V& v)
62512                 {
62513                         v.template operator()<SubscriberProfileIDforRFP>(1);
62514
62515                 }
62516                 protected:
62517                 template<typename V> bool decode(size_t index, V& v)
62518                 {
62519                         clear();
62520                         switch(index)
62521                         {
62522                         case 1: v(select_id_SubscriberProfileIDforRFP()); return true;
62523                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
62524                         }
62525                         return false;
62526
62527                 }
62528                 template<typename V> bool encode(size_t index, V& v) const
62529                 {
62530                         if(index != type) return false;
62531                         switch(type)
62532                         {
62533                         case 1: v(var.as<SubscriberProfileIDforRFP>()); return true;
62534                         }
62535                         return false;
62536
62537                 }
62538                 private:
62539                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
62540                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
62541                 union union_type
62542                 {
62543                         char dummy1[sizeof(SubscriberProfileIDforRFP)];
62544
62545                 };
62546                 asn::variant<sizeof(union_type)> var;
62547                 size_t type {0};
62548
62549         };
62550         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
62551         {
62552                 size_t get_index() const {return type;}
62553                 bool is_unknown() const { return type == 2; }
62554                 void clear() {type = 0;}
62555                 void select_id_SubscriberProfileIDforRFP() { set(optional); type=1;}
62556                 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
62557                 template<typename V>  bool decode(V& v)
62558                 {
62559                         clear();
62560                         if(!v(ref_nested())) return false;
62561                         if(equal(optional)) { type = 1; return true; }
62562                         else { type = 2; return true;}
62563                         return false;
62564
62565                 }
62566                 template<typename V> bool encode(V& v) const
62567                 {
62568                         return v(ref_nested());
62569
62570                 }
62571                 protected:
62572                 template<typename V>  bool decode(size_t index, V& v)
62573                 {
62574                         clear();
62575                         switch(index)
62576                         {
62577                         case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
62578                         case 2: type = 2; return v(ref_nested());
62579                         ref_nested().clear();
62580                         }
62581                         return false;
62582
62583                 }
62584                 template<typename V> bool encode(size_t index, V& v) const
62585                 {
62586                         if(index != type) {return false;} return v(ref_nested());
62587
62588                 }
62589                 private:
62590                 size_t type {0};
62591
62592         };
62593
62594 };
62595 /*
62596 UE-ContextInformation-SgNBModReq ::= SEQUENCE {
62597         nRUE-SecurityCapabilities               NRUESecurityCapabilities                                                                                                                        OPTIONAL,
62598         sgNB-SecurityKey                                SgNBSecurityKey                                                                                                                                         OPTIONAL,
62599         sgNBUEAggregateMaximumBitRate   UEAggregateMaximumBitRate                                                                                                                       OPTIONAL,
62600         e-RABs-ToBeAdded                                E-RABs-ToBeAdded-SgNBModReq-List                                                                                                        OPTIONAL,
62601         e-RABs-ToBeModified                             E-RABs-ToBeModified-SgNBModReq-List                                                                                                     OPTIONAL,
62602         e-RABs-ToBeReleased                             E-RABs-ToBeReleased-SgNBModReq-List                                                                                                     OPTIONAL,
62603         iE-Extensions                                   ProtocolExtensionContainer { {UE-ContextInformationSgNBModReqExtIEs} }                  OPTIONAL,
62604         ...
62605 }
62606 */
62607
62608 struct UE_ContextInformation_SgNBModReq : asn::sequence<7, 0, true, 7>
62609 {
62610         static constexpr const char* name() {return "UE-ContextInformation-SgNBModReq";}
62611         using parent_t = asn::sequence<7, 0, true, 7>;
62612         struct nRUE_SecurityCapabilities_t : NRUESecurityCapabilities
62613         {
62614                 static constexpr const char* name() {return "nRUE_SecurityCapabilities_t";}
62615                 using parent_t = NRUESecurityCapabilities;
62616                 static constexpr bool optional = true;
62617
62618         };
62619         nRUE_SecurityCapabilities_t& set_nRUE_SecurityCapabilities() { nRUE_SecurityCapabilities.setpresent(true); return nRUE_SecurityCapabilities;}
62620         nRUE_SecurityCapabilities_t const* get_nRUE_SecurityCapabilities() const {return nRUE_SecurityCapabilities.is_valid() ? &nRUE_SecurityCapabilities : nullptr;}
62621         struct sgNB_SecurityKey_t : SgNBSecurityKey
62622         {
62623                 static constexpr const char* name() {return "sgNB_SecurityKey_t";}
62624                 using parent_t = SgNBSecurityKey;
62625                 static constexpr bool optional = true;
62626
62627         };
62628         sgNB_SecurityKey_t& set_sgNB_SecurityKey() { sgNB_SecurityKey.setpresent(true); return sgNB_SecurityKey;}
62629         sgNB_SecurityKey_t const* get_sgNB_SecurityKey() const {return sgNB_SecurityKey.is_valid() ? &sgNB_SecurityKey : nullptr;}
62630         struct sgNBUEAggregateMaximumBitRate_t : UEAggregateMaximumBitRate
62631         {
62632                 static constexpr const char* name() {return "sgNBUEAggregateMaximumBitRate_t";}
62633                 using parent_t = UEAggregateMaximumBitRate;
62634                 static constexpr bool optional = true;
62635
62636         };
62637         sgNBUEAggregateMaximumBitRate_t& set_sgNBUEAggregateMaximumBitRate() { sgNBUEAggregateMaximumBitRate.setpresent(true); return sgNBUEAggregateMaximumBitRate;}
62638         sgNBUEAggregateMaximumBitRate_t const* get_sgNBUEAggregateMaximumBitRate() const {return sgNBUEAggregateMaximumBitRate.is_valid() ? &sgNBUEAggregateMaximumBitRate : nullptr;}
62639         struct e_RABs_ToBeAdded_t : E_RABs_ToBeAdded_SgNBModReq_List
62640         {
62641                 static constexpr const char* name() {return "e_RABs_ToBeAdded_t";}
62642                 using parent_t = E_RABs_ToBeAdded_SgNBModReq_List;
62643                 static constexpr bool optional = true;
62644
62645         };
62646         e_RABs_ToBeAdded_t& set_e_RABs_ToBeAdded() { e_RABs_ToBeAdded.setpresent(true); return e_RABs_ToBeAdded;}
62647         e_RABs_ToBeAdded_t const* get_e_RABs_ToBeAdded() const {return e_RABs_ToBeAdded.is_valid() ? &e_RABs_ToBeAdded : nullptr;}
62648         struct e_RABs_ToBeModified_t : E_RABs_ToBeModified_SgNBModReq_List
62649         {
62650                 static constexpr const char* name() {return "e_RABs_ToBeModified_t";}
62651                 using parent_t = E_RABs_ToBeModified_SgNBModReq_List;
62652                 static constexpr bool optional = true;
62653
62654         };
62655         e_RABs_ToBeModified_t& set_e_RABs_ToBeModified() { e_RABs_ToBeModified.setpresent(true); return e_RABs_ToBeModified;}
62656         e_RABs_ToBeModified_t const* get_e_RABs_ToBeModified() const {return e_RABs_ToBeModified.is_valid() ? &e_RABs_ToBeModified : nullptr;}
62657         struct e_RABs_ToBeReleased_t : E_RABs_ToBeReleased_SgNBModReq_List
62658         {
62659                 static constexpr const char* name() {return "e_RABs_ToBeReleased_t";}
62660                 using parent_t = E_RABs_ToBeReleased_SgNBModReq_List;
62661                 static constexpr bool optional = true;
62662
62663         };
62664         e_RABs_ToBeReleased_t& set_e_RABs_ToBeReleased() { e_RABs_ToBeReleased.setpresent(true); return e_RABs_ToBeReleased;}
62665         e_RABs_ToBeReleased_t const* get_e_RABs_ToBeReleased() const {return e_RABs_ToBeReleased.is_valid() ? &e_RABs_ToBeReleased : nullptr;}
62666         struct iE_Extensions_t : ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>
62667         {
62668                 static constexpr const char* name() {return "iE_Extensions_t";}
62669                 using parent_t = ProtocolExtensionContainer<UE_ContextInformationSgNBModReqExtIEs>;
62670                 static constexpr bool optional = true;
62671
62672         };
62673         iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
62674         iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
62675         template<typename V> void decode(V& v)
62676         {
62677                 v(nRUE_SecurityCapabilities);
62678                 v(sgNB_SecurityKey);
62679                 v(sgNBUEAggregateMaximumBitRate);
62680                 v(e_RABs_ToBeAdded);
62681                 v(e_RABs_ToBeModified);
62682                 v(e_RABs_ToBeReleased);
62683                 v(iE_Extensions);
62684
62685         };
62686         template<typename V> void encode(V& v) const
62687         {
62688                 v(nRUE_SecurityCapabilities);
62689                 v(sgNB_SecurityKey);
62690                 v(sgNBUEAggregateMaximumBitRate);
62691                 v(e_RABs_ToBeAdded);
62692                 v(e_RABs_ToBeModified);
62693                 v(e_RABs_ToBeReleased);
62694                 v(iE_Extensions);
62695
62696         };
62697         void clear()
62698         {
62699                 nRUE_SecurityCapabilities.clear();
62700                 sgNB_SecurityKey.clear();
62701                 sgNBUEAggregateMaximumBitRate.clear();
62702                 e_RABs_ToBeAdded.clear();
62703                 e_RABs_ToBeModified.clear();
62704                 e_RABs_ToBeReleased.clear();
62705                 iE_Extensions.clear();
62706
62707         };
62708         private:
62709         nRUE_SecurityCapabilities_t     nRUE_SecurityCapabilities;
62710         sgNB_SecurityKey_t      sgNB_SecurityKey;
62711         sgNBUEAggregateMaximumBitRate_t sgNBUEAggregateMaximumBitRate;
62712         e_RABs_ToBeAdded_t      e_RABs_ToBeAdded;
62713         e_RABs_ToBeModified_t   e_RABs_ToBeModified;
62714         e_RABs_ToBeReleased_t   e_RABs_ToBeReleased;
62715         iE_Extensions_t iE_Extensions;
62716
62717 };
62718 /*
62719 SgNBModificationRequest-IEs X2AP-PROTOCOL-IES ::= {
62720         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
62721         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                    PRESENCE mandatory}|
62722         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                                                              PRESENCE mandatory}|
62723         { ID id-SelectedPLMN                                            CRITICALITY ignore      TYPE PLMN-Identity                                                              PRESENCE optional}|
62724         { ID id-HandoverRestrictionList                         CRITICALITY ignore      TYPE HandoverRestrictionList                                    PRESENCE optional}|
62725         { ID    id-SCGConfigurationQuery                        CRITICALITY ignore      TYPE SCGConfigurationQuery                                              PRESENCE optional}|
62726         { ID id-UE-ContextInformation-SgNBModReq        CRITICALITY reject      TYPE UE-ContextInformation-SgNBModReq           PRESENCE optional}|
62727         { ID id-MeNBtoSgNBContainer                                     CRITICALITY reject      TYPE MeNBtoSgNBContainer                                                PRESENCE optional}|
62728         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
62729         { ID id-MeNBResourceCoordinationInformation     CRITICALITY ignore      TYPE MeNBResourceCoordinationInformation        PRESENCE optional}|
62730         { ID id-RequestedSplitSRBs                                      CRITICALITY ignore      TYPE SplitSRBs                                                                  PRESENCE optional}|
62731         { ID id-RequestedSplitSRBsrelease                       CRITICALITY ignore      TYPE SplitSRBs                                                                  PRESENCE optional},
62732         ...
62733 }
62734 */
62735
62736 struct SgNBModificationRequest_IEs
62737 {
62738         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
62739         {
62740                 size_t get_index() const {return type;}
62741                 bool is_unknown() const { return type == 13; }
62742                 void clear() {type = 0;}
62743                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
62744                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
62745                 void select_id_Cause() { set(id_Cause); type=3;}
62746                 void select_id_SelectedPLMN() { set(id_SelectedPLMN); type=4;}
62747                 void select_id_HandoverRestrictionList() { set(id_HandoverRestrictionList); type=5;}
62748                 void select_id_SCGConfigurationQuery() { set(id_SCGConfigurationQuery); type=6;}
62749                 void select_id_UE_ContextInformation_SgNBModReq() { set(id_UE_ContextInformation_SgNBModReq); type=7;}
62750                 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=8;}
62751                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
62752                 void select_id_MeNBResourceCoordinationInformation() { set(id_MeNBResourceCoordinationInformation); type=10;}
62753                 void select_id_RequestedSplitSRBs() { set(id_RequestedSplitSRBs); type=11;}
62754                 void select_id_RequestedSplitSRBsrelease() { set(id_RequestedSplitSRBsrelease); type=12;}
62755                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
62756                 template<typename V>  bool decode(V& v)
62757                 {
62758                         clear();
62759                         if(!v(ref_nested())) return false;
62760                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
62761                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
62762                         else if(equal(id_Cause)) { type = 3; return true; }
62763                         else if(equal(id_SelectedPLMN)) { type = 4; return true; }
62764                         else if(equal(id_HandoverRestrictionList)) { type = 5; return true; }
62765                         else if(equal(id_SCGConfigurationQuery)) { type = 6; return true; }
62766                         else if(equal(id_UE_ContextInformation_SgNBModReq)) { type = 7; return true; }
62767                         else if(equal(id_MeNBtoSgNBContainer)) { type = 8; return true; }
62768                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
62769                         else if(equal(id_MeNBResourceCoordinationInformation)) { type = 10; return true; }
62770                         else if(equal(id_RequestedSplitSRBs)) { type = 11; return true; }
62771                         else if(equal(id_RequestedSplitSRBsrelease)) { type = 12; return true; }
62772                         else { type = 13; return true;}
62773                         return false;
62774
62775                 }
62776                 template<typename V> bool encode(V& v) const
62777                 {
62778                         return v(ref_nested());
62779
62780                 }
62781                 protected:
62782                 template<typename V>  bool decode(size_t index, V& v)
62783                 {
62784                         clear();
62785                         switch(index)
62786                         {
62787                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
62788                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
62789                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
62790                         case 4: type = 4; if(v(ref_nested())) { return equal(id_SelectedPLMN);} return false;
62791                         case 5: type = 5; if(v(ref_nested())) { return equal(id_HandoverRestrictionList);} return false;
62792                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SCGConfigurationQuery);} return false;
62793                         case 7: type = 7; if(v(ref_nested())) { return equal(id_UE_ContextInformation_SgNBModReq);} return false;
62794                         case 8: type = 8; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
62795                         case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
62796                         case 10: type = 10; if(v(ref_nested())) { return equal(id_MeNBResourceCoordinationInformation);} return false;
62797                         case 11: type = 11; if(v(ref_nested())) { return equal(id_RequestedSplitSRBs);} return false;
62798                         case 12: type = 12; if(v(ref_nested())) { return equal(id_RequestedSplitSRBsrelease);} return false;
62799                         case 13: type = 13; return v(ref_nested());
62800                         ref_nested().clear();
62801                         }
62802                         return false;
62803
62804                 }
62805                 template<typename V> bool encode(size_t index, V& v) const
62806                 {
62807                         if(index != type) {return false;} return v(ref_nested());
62808
62809                 }
62810                 private:
62811                 size_t type {0};
62812
62813         };
62814         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
62815         {
62816                 size_t get_index() const {return type;}
62817                 bool is_unknown() const { return type == 13; }
62818                 void clear() {type = 0;}
62819                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
62820                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
62821                 void select_id_Cause() { set(ignore); type=3;}
62822                 void select_id_SelectedPLMN() { set(ignore); type=4;}
62823                 void select_id_HandoverRestrictionList() { set(ignore); type=5;}
62824                 void select_id_SCGConfigurationQuery() { set(ignore); type=6;}
62825                 void select_id_UE_ContextInformation_SgNBModReq() { set(reject); type=7;}
62826                 void select_id_MeNBtoSgNBContainer() { set(reject); type=8;}
62827                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=9;}
62828                 void select_id_MeNBResourceCoordinationInformation() { set(ignore); type=10;}
62829                 void select_id_RequestedSplitSRBs() { set(ignore); type=11;}
62830                 void select_id_RequestedSplitSRBsrelease() { set(ignore); type=12;}
62831                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
62832                 template<typename V>  bool decode(V& v)
62833                 {
62834                         clear();
62835                         if(!v(ref_nested())) return false;
62836                         if(equal(reject)) { type = 1; return true; }
62837                         else if(equal(reject)) { type = 2; return true; }
62838                         else if(equal(ignore)) { type = 3; return true; }
62839                         else if(equal(ignore)) { type = 4; return true; }
62840                         else if(equal(ignore)) { type = 5; return true; }
62841                         else if(equal(ignore)) { type = 6; return true; }
62842                         else if(equal(reject)) { type = 7; return true; }
62843                         else if(equal(reject)) { type = 8; return true; }
62844                         else if(equal(reject)) { type = 9; return true; }
62845                         else if(equal(ignore)) { type = 10; return true; }
62846                         else if(equal(ignore)) { type = 11; return true; }
62847                         else if(equal(ignore)) { type = 12; return true; }
62848                         else { type = 13; return true;}
62849                         return false;
62850
62851                 }
62852                 template<typename V> bool encode(V& v) const
62853                 {
62854                         return v(ref_nested());
62855
62856                 }
62857                 protected:
62858                 template<typename V>  bool decode(size_t index, V& v)
62859                 {
62860                         clear();
62861                         switch(index)
62862                         {
62863                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
62864                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
62865                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
62866                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
62867                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
62868                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
62869                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
62870                         case 8: type = 8; if(v(ref_nested())) { return equal(reject);} return false;
62871                         case 9: type = 9; if(v(ref_nested())) { return equal(reject);} return false;
62872                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
62873                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
62874                         case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
62875                         case 13: type = 13; return v(ref_nested());
62876                         ref_nested().clear();
62877                         }
62878                         return false;
62879
62880                 }
62881                 template<typename V> bool encode(size_t index, V& v) const
62882                 {
62883                         if(index != type) {return false;} return v(ref_nested());
62884
62885                 }
62886                 private:
62887                 size_t type {0};
62888
62889         };
62890         struct Value_t : asn::typefield<true>
62891         {
62892                 ~Value_t()      {clear();}
62893                 size_t get_index() const {return type;}
62894                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
62895                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
62896                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
62897                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
62898                 Cause& select_id_Cause() { return set<Cause>(3); }
62899                 Cause const* get_id_Cause() const { return get<Cause>(3); }
62900                 PLMN_Identity& select_id_SelectedPLMN() { return set<PLMN_Identity>(4); }
62901                 PLMN_Identity const* get_id_SelectedPLMN() const { return get<PLMN_Identity>(4); }
62902                 HandoverRestrictionList& select_id_HandoverRestrictionList() { return set<HandoverRestrictionList>(5); }
62903                 HandoverRestrictionList const* get_id_HandoverRestrictionList() const { return get<HandoverRestrictionList>(5); }
62904                 SCGConfigurationQuery& select_id_SCGConfigurationQuery() { return set<SCGConfigurationQuery>(6); }
62905                 SCGConfigurationQuery const* get_id_SCGConfigurationQuery() const { return get<SCGConfigurationQuery>(6); }
62906                 UE_ContextInformation_SgNBModReq& select_id_UE_ContextInformation_SgNBModReq() { return set<UE_ContextInformation_SgNBModReq>(7); }
62907                 UE_ContextInformation_SgNBModReq const* get_id_UE_ContextInformation_SgNBModReq() const { return get<UE_ContextInformation_SgNBModReq>(7); }
62908                 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(8); }
62909                 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(8); }
62910                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
62911                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
62912                 MeNBResourceCoordinationInformation& select_id_MeNBResourceCoordinationInformation() { return set<MeNBResourceCoordinationInformation>(10); }
62913                 MeNBResourceCoordinationInformation const* get_id_MeNBResourceCoordinationInformation() const { return get<MeNBResourceCoordinationInformation>(10); }
62914                 SplitSRBs& select_id_RequestedSplitSRBs() { return set<SplitSRBs>(11); }
62915                 SplitSRBs const* get_id_RequestedSplitSRBs() const { return get<SplitSRBs>(11); }
62916                 SplitSRBs& select_id_RequestedSplitSRBsrelease() { return set<SplitSRBs>(12); }
62917                 SplitSRBs const* get_id_RequestedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
62918                 bool is_unknown() const { return type == 13; }
62919                 void clear()
62920                 {
62921                         switch(type)
62922                         {
62923                         case 1: var.destroy<UE_X2AP_ID>(); break;
62924                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
62925                         case 3: var.destroy<Cause>(); break;
62926                         case 4: var.destroy<PLMN_Identity>(); break;
62927                         case 5: var.destroy<HandoverRestrictionList>(); break;
62928                         case 6: var.destroy<SCGConfigurationQuery>(); break;
62929                         case 7: var.destroy<UE_ContextInformation_SgNBModReq>(); break;
62930                         case 8: var.destroy<MeNBtoSgNBContainer>(); break;
62931                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
62932                         case 10: var.destroy<MeNBResourceCoordinationInformation>(); break;
62933                         case 11: var.destroy<SplitSRBs>(); break;
62934                         case 12: var.destroy<SplitSRBs>(); break;
62935                         }
62936                         type = 0; ref_nested().clear();
62937                 }
62938                 template<typename V> static inline void enumerate(V& v)
62939                 {
62940                         v.template operator()<UE_X2AP_ID>(1);
62941                         v.template operator()<SgNB_UE_X2AP_ID>(2);
62942                         v.template operator()<Cause>(3);
62943                         v.template operator()<PLMN_Identity>(4);
62944                         v.template operator()<HandoverRestrictionList>(5);
62945                         v.template operator()<SCGConfigurationQuery>(6);
62946                         v.template operator()<UE_ContextInformation_SgNBModReq>(7);
62947                         v.template operator()<MeNBtoSgNBContainer>(8);
62948                         v.template operator()<UE_X2AP_ID_Extension>(9);
62949                         v.template operator()<MeNBResourceCoordinationInformation>(10);
62950                         v.template operator()<SplitSRBs>(11);
62951                         v.template operator()<SplitSRBs>(12);
62952
62953                 }
62954                 protected:
62955                 template<typename V> bool decode(size_t index, V& v)
62956                 {
62957                         clear();
62958                         switch(index)
62959                         {
62960                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
62961                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
62962                         case 3: v(select_id_Cause()); return true;
62963                         case 4: v(select_id_SelectedPLMN()); return true;
62964                         case 5: v(select_id_HandoverRestrictionList()); return true;
62965                         case 6: v(select_id_SCGConfigurationQuery()); return true;
62966                         case 7: v(select_id_UE_ContextInformation_SgNBModReq()); return true;
62967                         case 8: v(select_id_MeNBtoSgNBContainer()); return true;
62968                         case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
62969                         case 10: v(select_id_MeNBResourceCoordinationInformation()); return true;
62970                         case 11: v(select_id_RequestedSplitSRBs()); return true;
62971                         case 12: v(select_id_RequestedSplitSRBsrelease()); return true;
62972                         case 13: if(type != 13) {clear(); asn::base::set();} type = 13; return true;
62973                         }
62974                         return false;
62975
62976                 }
62977                 template<typename V> bool encode(size_t index, V& v) const
62978                 {
62979                         if(index != type) return false;
62980                         switch(type)
62981                         {
62982                         case 1: v(var.as<UE_X2AP_ID>()); return true;
62983                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
62984                         case 3: v(var.as<Cause>()); return true;
62985                         case 4: v(var.as<PLMN_Identity>()); return true;
62986                         case 5: v(var.as<HandoverRestrictionList>()); return true;
62987                         case 6: v(var.as<SCGConfigurationQuery>()); return true;
62988                         case 7: v(var.as<UE_ContextInformation_SgNBModReq>()); return true;
62989                         case 8: v(var.as<MeNBtoSgNBContainer>()); return true;
62990                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
62991                         case 10: v(var.as<MeNBResourceCoordinationInformation>()); return true;
62992                         case 11: v(var.as<SplitSRBs>()); return true;
62993                         case 12: v(var.as<SplitSRBs>()); return true;
62994                         }
62995                         return false;
62996
62997                 }
62998                 private:
62999                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63000                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63001                 union union_type
63002                 {
63003                         char dummy1[sizeof(Cause)];
63004                         char dummy2[sizeof(HandoverRestrictionList)];
63005                         char dummy3[sizeof(MeNBResourceCoordinationInformation)];
63006                         char dummy4[sizeof(MeNBtoSgNBContainer)];
63007                         char dummy5[sizeof(PLMN_Identity)];
63008                         char dummy6[sizeof(SCGConfigurationQuery)];
63009                         char dummy7[sizeof(SgNB_UE_X2AP_ID)];
63010                         char dummy8[sizeof(SplitSRBs)];
63011                         char dummy9[sizeof(UE_ContextInformation_SgNBModReq)];
63012                         char dummy10[sizeof(UE_X2AP_ID)];
63013                         char dummy11[sizeof(UE_X2AP_ID_Extension)];
63014
63015                 };
63016                 asn::variant<sizeof(union_type)> var;
63017                 size_t type {0};
63018
63019         };
63020         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63021         {
63022                 size_t get_index() const {return type;}
63023                 bool is_unknown() const { return type == 13; }
63024                 void clear() {type = 0;}
63025                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63026                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63027                 void select_id_Cause() { set(mandatory); type=3;}
63028                 void select_id_SelectedPLMN() { set(optional); type=4;}
63029                 void select_id_HandoverRestrictionList() { set(optional); type=5;}
63030                 void select_id_SCGConfigurationQuery() { set(optional); type=6;}
63031                 void select_id_UE_ContextInformation_SgNBModReq() { set(optional); type=7;}
63032                 void select_id_MeNBtoSgNBContainer() { set(optional); type=8;}
63033                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
63034                 void select_id_MeNBResourceCoordinationInformation() { set(optional); type=10;}
63035                 void select_id_RequestedSplitSRBs() { set(optional); type=11;}
63036                 void select_id_RequestedSplitSRBsrelease() { set(optional); type=12;}
63037                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63038                 template<typename V>  bool decode(V& v)
63039                 {
63040                         clear();
63041                         if(!v(ref_nested())) return false;
63042                         if(equal(mandatory)) { type = 1; return true; }
63043                         else if(equal(mandatory)) { type = 2; return true; }
63044                         else if(equal(mandatory)) { type = 3; return true; }
63045                         else if(equal(optional)) { type = 4; return true; }
63046                         else if(equal(optional)) { type = 5; return true; }
63047                         else if(equal(optional)) { type = 6; return true; }
63048                         else if(equal(optional)) { type = 7; return true; }
63049                         else if(equal(optional)) { type = 8; return true; }
63050                         else if(equal(optional)) { type = 9; return true; }
63051                         else if(equal(optional)) { type = 10; return true; }
63052                         else if(equal(optional)) { type = 11; return true; }
63053                         else if(equal(optional)) { type = 12; return true; }
63054                         else { type = 13; return true;}
63055                         return false;
63056
63057                 }
63058                 template<typename V> bool encode(V& v) const
63059                 {
63060                         return v(ref_nested());
63061
63062                 }
63063                 protected:
63064                 template<typename V>  bool decode(size_t index, V& v)
63065                 {
63066                         clear();
63067                         switch(index)
63068                         {
63069                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63070                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63071                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
63072                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63073                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63074                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
63075                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
63076                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
63077                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
63078                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
63079                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
63080                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
63081                         case 13: type = 13; return v(ref_nested());
63082                         ref_nested().clear();
63083                         }
63084                         return false;
63085
63086                 }
63087                 template<typename V> bool encode(size_t index, V& v) const
63088                 {
63089                         if(index != type) {return false;} return v(ref_nested());
63090
63091                 }
63092                 private:
63093                 size_t type {0};
63094
63095         };
63096
63097 };
63098 /*
63099 SgNBModificationRequest ::= SEQUENCE {
63100         protocolIEs             ProtocolIE-Container    {{ SgNBModificationRequest-IEs}},
63101         ...
63102 }
63103 */
63104
63105 struct SgNBModificationRequest : asn::sequence<1, 0, true, 0>
63106 {
63107         static constexpr const char* name() {return "SgNBModificationRequest";}
63108         using parent_t = asn::sequence<1, 0, true, 0>;
63109         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequest_IEs>
63110         {
63111                 static constexpr const char* name() {return "protocolIEs_t";}
63112                 using parent_t = ProtocolIE_Container<SgNBModificationRequest_IEs>;
63113
63114         };
63115         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63116         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63117         template<typename V> void decode(V& v)
63118         {
63119                 v(protocolIEs);
63120
63121         };
63122         template<typename V> void encode(V& v) const
63123         {
63124                 v(protocolIEs);
63125
63126         };
63127         void clear()
63128         {
63129                 protocolIEs.clear();
63130
63131         };
63132         private:
63133         protocolIEs_t   protocolIEs;
63134
63135 };
63136 /*
63137 SgNBModificationRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
63138         { ID id-MeNB-UE-X2AP-ID                                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                                                                                 PRESENCE mandatory}|
63139         { ID id-SgNB-UE-X2AP-ID                                                         CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                                            PRESENCE mandatory}|
63140         { ID id-E-RABs-Admitted-ToBeAdded-SgNBModAckList                CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeAdded-SgNBModAckList                   PRESENCE optional}|
63141         { ID id-E-RABs-Admitted-ToBeModified-SgNBModAckList     CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeModified-SgNBModAckList                PRESENCE optional}|
63142         { ID id-E-RABs-Admitted-ToBeReleased-SgNBModAckList     CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeReleased-SgNBModAckList                PRESENCE optional}|
63143         { ID id-E-RABs-NotAdmitted-List                                         CRITICALITY ignore      TYPE E-RAB-List                                                                                                 PRESENCE optional}|
63144         { ID id-SgNBtoMeNBContainer                                                     CRITICALITY ignore      TYPE SgNBtoMeNBContainer                                                                                PRESENCE optional}|
63145         { ID id-CriticalityDiagnostics                                          CRITICALITY ignore      TYPE CriticalityDiagnostics                                                                     PRESENCE optional}|
63146         { ID id-MeNB-UE-X2AP-ID-Extension                                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                                       PRESENCE optional}|
63147         { ID id-SgNBResourceCoordinationInformation                     CRITICALITY ignore      TYPE SgNBResourceCoordinationInformation                                PRESENCE optional}|
63148         { ID id-AdmittedSplitSRBs                                                       CRITICALITY ignore      TYPE SplitSRBs                                                                                                  PRESENCE optional}|
63149         { ID id-AdmittedSplitSRBsrelease                                                CRITICALITY ignore      TYPE SplitSRBs                                                                                                  PRESENCE optional}|
63150         { ID id-RRCConfigIndication                                                     CRITICALITY reject      TYPE RRC-Config-Ind                     PRESENCE optional},
63151         ...
63152 }
63153 */
63154
63155 struct SgNBModificationRequestAcknowledge_IEs
63156 {
63157         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63158         {
63159                 size_t get_index() const {return type;}
63160                 bool is_unknown() const { return type == 14; }
63161                 void clear() {type = 0;}
63162                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63163                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63164                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList); type=3;}
63165                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeModified_SgNBModAckList); type=4;}
63166                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList); type=5;}
63167                 void select_id_E_RABs_NotAdmitted_List() { set(id_E_RABs_NotAdmitted_List); type=6;}
63168                 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=7;}
63169                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=8;}
63170                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=9;}
63171                 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=10;}
63172                 void select_id_AdmittedSplitSRBs() { set(id_AdmittedSplitSRBs); type=11;}
63173                 void select_id_AdmittedSplitSRBsrelease() { set(id_AdmittedSplitSRBsrelease); type=12;}
63174                 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=13;}
63175                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63176                 template<typename V>  bool decode(V& v)
63177                 {
63178                         clear();
63179                         if(!v(ref_nested())) return false;
63180                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63181                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63182                         else if(equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList)) { type = 3; return true; }
63183                         else if(equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList)) { type = 4; return true; }
63184                         else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList)) { type = 5; return true; }
63185                         else if(equal(id_E_RABs_NotAdmitted_List)) { type = 6; return true; }
63186                         else if(equal(id_SgNBtoMeNBContainer)) { type = 7; return true; }
63187                         else if(equal(id_CriticalityDiagnostics)) { type = 8; return true; }
63188                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 9; return true; }
63189                         else if(equal(id_SgNBResourceCoordinationInformation)) { type = 10; return true; }
63190                         else if(equal(id_AdmittedSplitSRBs)) { type = 11; return true; }
63191                         else if(equal(id_AdmittedSplitSRBsrelease)) { type = 12; return true; }
63192                         else if(equal(id_RRCConfigIndication)) { type = 13; return true; }
63193                         else { type = 14; return true;}
63194                         return false;
63195
63196                 }
63197                 template<typename V> bool encode(V& v) const
63198                 {
63199                         return v(ref_nested());
63200
63201                 }
63202                 protected:
63203                 template<typename V>  bool decode(size_t index, V& v)
63204                 {
63205                         clear();
63206                         switch(index)
63207                         {
63208                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63209                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63210                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeAdded_SgNBModAckList);} return false;
63211                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeModified_SgNBModAckList);} return false;
63212                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBModAckList);} return false;
63213                         case 6: type = 6; if(v(ref_nested())) { return equal(id_E_RABs_NotAdmitted_List);} return false;
63214                         case 7: type = 7; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
63215                         case 8: type = 8; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
63216                         case 9: type = 9; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63217                         case 10: type = 10; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
63218                         case 11: type = 11; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBs);} return false;
63219                         case 12: type = 12; if(v(ref_nested())) { return equal(id_AdmittedSplitSRBsrelease);} return false;
63220                         case 13: type = 13; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
63221                         case 14: type = 14; return v(ref_nested());
63222                         ref_nested().clear();
63223                         }
63224                         return false;
63225
63226                 }
63227                 template<typename V> bool encode(size_t index, V& v) const
63228                 {
63229                         if(index != type) {return false;} return v(ref_nested());
63230
63231                 }
63232                 private:
63233                 size_t type {0};
63234
63235         };
63236         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63237         {
63238                 size_t get_index() const {return type;}
63239                 bool is_unknown() const { return type == 14; }
63240                 void clear() {type = 0;}
63241                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
63242                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
63243                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(ignore); type=3;}
63244                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(ignore); type=4;}
63245                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(ignore); type=5;}
63246                 void select_id_E_RABs_NotAdmitted_List() { set(ignore); type=6;}
63247                 void select_id_SgNBtoMeNBContainer() { set(ignore); type=7;}
63248                 void select_id_CriticalityDiagnostics() { set(ignore); type=8;}
63249                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=9;}
63250                 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=10;}
63251                 void select_id_AdmittedSplitSRBs() { set(ignore); type=11;}
63252                 void select_id_AdmittedSplitSRBsrelease() { set(ignore); type=12;}
63253                 void select_id_RRCConfigIndication() { set(reject); type=13;}
63254                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63255                 template<typename V>  bool decode(V& v)
63256                 {
63257                         clear();
63258                         if(!v(ref_nested())) return false;
63259                         if(equal(ignore)) { type = 1; return true; }
63260                         else if(equal(ignore)) { type = 2; return true; }
63261                         else if(equal(ignore)) { type = 3; return true; }
63262                         else if(equal(ignore)) { type = 4; return true; }
63263                         else if(equal(ignore)) { type = 5; return true; }
63264                         else if(equal(ignore)) { type = 6; return true; }
63265                         else if(equal(ignore)) { type = 7; return true; }
63266                         else if(equal(ignore)) { type = 8; return true; }
63267                         else if(equal(ignore)) { type = 9; return true; }
63268                         else if(equal(ignore)) { type = 10; return true; }
63269                         else if(equal(ignore)) { type = 11; return true; }
63270                         else if(equal(ignore)) { type = 12; return true; }
63271                         else if(equal(reject)) { type = 13; return true; }
63272                         else { type = 14; return true;}
63273                         return false;
63274
63275                 }
63276                 template<typename V> bool encode(V& v) const
63277                 {
63278                         return v(ref_nested());
63279
63280                 }
63281                 protected:
63282                 template<typename V>  bool decode(size_t index, V& v)
63283                 {
63284                         clear();
63285                         switch(index)
63286                         {
63287                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
63288                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
63289                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
63290                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
63291                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
63292                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
63293                         case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
63294                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
63295                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
63296                         case 10: type = 10; if(v(ref_nested())) { return equal(ignore);} return false;
63297                         case 11: type = 11; if(v(ref_nested())) { return equal(ignore);} return false;
63298                         case 12: type = 12; if(v(ref_nested())) { return equal(ignore);} return false;
63299                         case 13: type = 13; if(v(ref_nested())) { return equal(reject);} return false;
63300                         case 14: type = 14; return v(ref_nested());
63301                         ref_nested().clear();
63302                         }
63303                         return false;
63304
63305                 }
63306                 template<typename V> bool encode(size_t index, V& v) const
63307                 {
63308                         if(index != type) {return false;} return v(ref_nested());
63309
63310                 }
63311                 private:
63312                 size_t type {0};
63313
63314         };
63315         struct Value_t : asn::typefield<true>
63316         {
63317                 ~Value_t()      {clear();}
63318                 size_t get_index() const {return type;}
63319                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
63320                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
63321                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
63322                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
63323                 E_RABs_Admitted_ToBeAdded_SgNBModAckList& select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { return set<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
63324                 E_RABs_Admitted_ToBeAdded_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3); }
63325                 E_RABs_Admitted_ToBeModified_SgNBModAckList& select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { return set<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
63326                 E_RABs_Admitted_ToBeModified_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4); }
63327                 E_RABs_Admitted_ToBeReleased_SgNBModAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
63328                 E_RABs_Admitted_ToBeReleased_SgNBModAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5); }
63329                 E_RAB_List& select_id_E_RABs_NotAdmitted_List() { return set<E_RAB_List>(6); }
63330                 E_RAB_List const* get_id_E_RABs_NotAdmitted_List() const { return get<E_RAB_List>(6); }
63331                 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(7); }
63332                 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(7); }
63333                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(8); }
63334                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(8); }
63335                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(9); }
63336                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(9); }
63337                 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(10); }
63338                 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(10); }
63339                 SplitSRBs& select_id_AdmittedSplitSRBs() { return set<SplitSRBs>(11); }
63340                 SplitSRBs const* get_id_AdmittedSplitSRBs() const { return get<SplitSRBs>(11); }
63341                 SplitSRBs& select_id_AdmittedSplitSRBsrelease() { return set<SplitSRBs>(12); }
63342                 SplitSRBs const* get_id_AdmittedSplitSRBsrelease() const { return get<SplitSRBs>(12); }
63343                 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(13); }
63344                 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(13); }
63345                 bool is_unknown() const { return type == 14; }
63346                 void clear()
63347                 {
63348                         switch(type)
63349                         {
63350                         case 1: var.destroy<UE_X2AP_ID>(); break;
63351                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
63352                         case 3: var.destroy<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(); break;
63353                         case 4: var.destroy<E_RABs_Admitted_ToBeModified_SgNBModAckList>(); break;
63354                         case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(); break;
63355                         case 6: var.destroy<E_RAB_List>(); break;
63356                         case 7: var.destroy<SgNBtoMeNBContainer>(); break;
63357                         case 8: var.destroy<CriticalityDiagnostics>(); break;
63358                         case 9: var.destroy<UE_X2AP_ID_Extension>(); break;
63359                         case 10: var.destroy<SgNBResourceCoordinationInformation>(); break;
63360                         case 11: var.destroy<SplitSRBs>(); break;
63361                         case 12: var.destroy<SplitSRBs>(); break;
63362                         case 13: var.destroy<RRC_Config_Ind>(); break;
63363                         }
63364                         type = 0; ref_nested().clear();
63365                 }
63366                 template<typename V> static inline void enumerate(V& v)
63367                 {
63368                         v.template operator()<UE_X2AP_ID>(1);
63369                         v.template operator()<SgNB_UE_X2AP_ID>(2);
63370                         v.template operator()<E_RABs_Admitted_ToBeAdded_SgNBModAckList>(3);
63371                         v.template operator()<E_RABs_Admitted_ToBeModified_SgNBModAckList>(4);
63372                         v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBModAckList>(5);
63373                         v.template operator()<E_RAB_List>(6);
63374                         v.template operator()<SgNBtoMeNBContainer>(7);
63375                         v.template operator()<CriticalityDiagnostics>(8);
63376                         v.template operator()<UE_X2AP_ID_Extension>(9);
63377                         v.template operator()<SgNBResourceCoordinationInformation>(10);
63378                         v.template operator()<SplitSRBs>(11);
63379                         v.template operator()<SplitSRBs>(12);
63380                         v.template operator()<RRC_Config_Ind>(13);
63381
63382                 }
63383                 protected:
63384                 template<typename V> bool decode(size_t index, V& v)
63385                 {
63386                         clear();
63387                         switch(index)
63388                         {
63389                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
63390                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
63391                         case 3: v(select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList()); return true;
63392                         case 4: v(select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList()); return true;
63393                         case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList()); return true;
63394                         case 6: v(select_id_E_RABs_NotAdmitted_List()); return true;
63395                         case 7: v(select_id_SgNBtoMeNBContainer()); return true;
63396                         case 8: v(select_id_CriticalityDiagnostics()); return true;
63397                         case 9: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
63398                         case 10: v(select_id_SgNBResourceCoordinationInformation()); return true;
63399                         case 11: v(select_id_AdmittedSplitSRBs()); return true;
63400                         case 12: v(select_id_AdmittedSplitSRBsrelease()); return true;
63401                         case 13: v(select_id_RRCConfigIndication()); return true;
63402                         case 14: if(type != 14) {clear(); asn::base::set();} type = 14; return true;
63403                         }
63404                         return false;
63405
63406                 }
63407                 template<typename V> bool encode(size_t index, V& v) const
63408                 {
63409                         if(index != type) return false;
63410                         switch(type)
63411                         {
63412                         case 1: v(var.as<UE_X2AP_ID>()); return true;
63413                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
63414                         case 3: v(var.as<E_RABs_Admitted_ToBeAdded_SgNBModAckList>()); return true;
63415                         case 4: v(var.as<E_RABs_Admitted_ToBeModified_SgNBModAckList>()); return true;
63416                         case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBModAckList>()); return true;
63417                         case 6: v(var.as<E_RAB_List>()); return true;
63418                         case 7: v(var.as<SgNBtoMeNBContainer>()); return true;
63419                         case 8: v(var.as<CriticalityDiagnostics>()); return true;
63420                         case 9: v(var.as<UE_X2AP_ID_Extension>()); return true;
63421                         case 10: v(var.as<SgNBResourceCoordinationInformation>()); return true;
63422                         case 11: v(var.as<SplitSRBs>()); return true;
63423                         case 12: v(var.as<SplitSRBs>()); return true;
63424                         case 13: v(var.as<RRC_Config_Ind>()); return true;
63425                         }
63426                         return false;
63427
63428                 }
63429                 private:
63430                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63431                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63432                 union union_type
63433                 {
63434                         char dummy1[sizeof(CriticalityDiagnostics)];
63435                         char dummy2[sizeof(E_RAB_List)];
63436                         char dummy3[sizeof(E_RABs_Admitted_ToBeAdded_SgNBModAckList)];
63437                         char dummy4[sizeof(E_RABs_Admitted_ToBeModified_SgNBModAckList)];
63438                         char dummy5[sizeof(E_RABs_Admitted_ToBeReleased_SgNBModAckList)];
63439                         char dummy6[sizeof(RRC_Config_Ind)];
63440                         char dummy7[sizeof(SgNBResourceCoordinationInformation)];
63441                         char dummy8[sizeof(SgNB_UE_X2AP_ID)];
63442                         char dummy9[sizeof(SgNBtoMeNBContainer)];
63443                         char dummy10[sizeof(SplitSRBs)];
63444                         char dummy11[sizeof(UE_X2AP_ID)];
63445                         char dummy12[sizeof(UE_X2AP_ID_Extension)];
63446
63447                 };
63448                 asn::variant<sizeof(union_type)> var;
63449                 size_t type {0};
63450
63451         };
63452         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63453         {
63454                 size_t get_index() const {return type;}
63455                 bool is_unknown() const { return type == 14; }
63456                 void clear() {type = 0;}
63457                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63458                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63459                 void select_id_E_RABs_Admitted_ToBeAdded_SgNBModAckList() { set(optional); type=3;}
63460                 void select_id_E_RABs_Admitted_ToBeModified_SgNBModAckList() { set(optional); type=4;}
63461                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBModAckList() { set(optional); type=5;}
63462                 void select_id_E_RABs_NotAdmitted_List() { set(optional); type=6;}
63463                 void select_id_SgNBtoMeNBContainer() { set(optional); type=7;}
63464                 void select_id_CriticalityDiagnostics() { set(optional); type=8;}
63465                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=9;}
63466                 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=10;}
63467                 void select_id_AdmittedSplitSRBs() { set(optional); type=11;}
63468                 void select_id_AdmittedSplitSRBsrelease() { set(optional); type=12;}
63469                 void select_id_RRCConfigIndication() { set(optional); type=13;}
63470                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63471                 template<typename V>  bool decode(V& v)
63472                 {
63473                         clear();
63474                         if(!v(ref_nested())) return false;
63475                         if(equal(mandatory)) { type = 1; return true; }
63476                         else if(equal(mandatory)) { type = 2; return true; }
63477                         else if(equal(optional)) { type = 3; return true; }
63478                         else if(equal(optional)) { type = 4; return true; }
63479                         else if(equal(optional)) { type = 5; return true; }
63480                         else if(equal(optional)) { type = 6; return true; }
63481                         else if(equal(optional)) { type = 7; return true; }
63482                         else if(equal(optional)) { type = 8; return true; }
63483                         else if(equal(optional)) { type = 9; return true; }
63484                         else if(equal(optional)) { type = 10; return true; }
63485                         else if(equal(optional)) { type = 11; return true; }
63486                         else if(equal(optional)) { type = 12; return true; }
63487                         else if(equal(optional)) { type = 13; return true; }
63488                         else { type = 14; return true;}
63489                         return false;
63490
63491                 }
63492                 template<typename V> bool encode(V& v) const
63493                 {
63494                         return v(ref_nested());
63495
63496                 }
63497                 protected:
63498                 template<typename V>  bool decode(size_t index, V& v)
63499                 {
63500                         clear();
63501                         switch(index)
63502                         {
63503                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63504                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63505                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
63506                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63507                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63508                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
63509                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
63510                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
63511                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
63512                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
63513                         case 11: type = 11; if(v(ref_nested())) { return equal(optional);} return false;
63514                         case 12: type = 12; if(v(ref_nested())) { return equal(optional);} return false;
63515                         case 13: type = 13; if(v(ref_nested())) { return equal(optional);} return false;
63516                         case 14: type = 14; return v(ref_nested());
63517                         ref_nested().clear();
63518                         }
63519                         return false;
63520
63521                 }
63522                 template<typename V> bool encode(size_t index, V& v) const
63523                 {
63524                         if(index != type) {return false;} return v(ref_nested());
63525
63526                 }
63527                 private:
63528                 size_t type {0};
63529
63530         };
63531
63532 };
63533 /*
63534 SgNBModificationRequestAcknowledge ::= SEQUENCE {
63535         protocolIEs             ProtocolIE-Container    {{SgNBModificationRequestAcknowledge-IEs}},
63536         ...
63537 }
63538 */
63539
63540 struct SgNBModificationRequestAcknowledge : asn::sequence<1, 0, true, 0>
63541 {
63542         static constexpr const char* name() {return "SgNBModificationRequestAcknowledge";}
63543         using parent_t = asn::sequence<1, 0, true, 0>;
63544         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>
63545         {
63546                 static constexpr const char* name() {return "protocolIEs_t";}
63547                 using parent_t = ProtocolIE_Container<SgNBModificationRequestAcknowledge_IEs>;
63548
63549         };
63550         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63551         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63552         template<typename V> void decode(V& v)
63553         {
63554                 v(protocolIEs);
63555
63556         };
63557         template<typename V> void encode(V& v) const
63558         {
63559                 v(protocolIEs);
63560
63561         };
63562         void clear()
63563         {
63564                 protocolIEs.clear();
63565
63566         };
63567         private:
63568         protocolIEs_t   protocolIEs;
63569
63570 };
63571 /*
63572 SgNBModificationRequestReject-IEs X2AP-PROTOCOL-IES ::= {
63573         { ID id-MeNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE UE-X2AP-ID                                 PRESENCE mandatory}|
63574         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                            PRESENCE mandatory}|
63575         { ID id-Cause                                                           CRITICALITY ignore      TYPE Cause                                              PRESENCE mandatory}|
63576         { ID id-CriticalityDiagnostics                          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional}|
63577         { ID id-MeNB-UE-X2AP-ID-Extension                       CRITICALITY ignore      TYPE UE-X2AP-ID-Extension               PRESENCE optional},
63578         ...
63579 }
63580 */
63581
63582 struct SgNBModificationRequestReject_IEs
63583 {
63584         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63585         {
63586                 size_t get_index() const {return type;}
63587                 bool is_unknown() const { return type == 6; }
63588                 void clear() {type = 0;}
63589                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63590                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63591                 void select_id_Cause() { set(id_Cause); type=3;}
63592                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
63593                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
63594                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63595                 template<typename V>  bool decode(V& v)
63596                 {
63597                         clear();
63598                         if(!v(ref_nested())) return false;
63599                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63600                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63601                         else if(equal(id_Cause)) { type = 3; return true; }
63602                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
63603                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
63604                         else { type = 6; return true;}
63605                         return false;
63606
63607                 }
63608                 template<typename V> bool encode(V& v) const
63609                 {
63610                         return v(ref_nested());
63611
63612                 }
63613                 protected:
63614                 template<typename V>  bool decode(size_t index, V& v)
63615                 {
63616                         clear();
63617                         switch(index)
63618                         {
63619                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63620                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63621                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
63622                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
63623                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63624                         case 6: type = 6; return v(ref_nested());
63625                         ref_nested().clear();
63626                         }
63627                         return false;
63628
63629                 }
63630                 template<typename V> bool encode(size_t index, V& v) const
63631                 {
63632                         if(index != type) {return false;} return v(ref_nested());
63633
63634                 }
63635                 private:
63636                 size_t type {0};
63637
63638         };
63639         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63640         {
63641                 size_t get_index() const {return type;}
63642                 bool is_unknown() const { return type == 6; }
63643                 void clear() {type = 0;}
63644                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
63645                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
63646                 void select_id_Cause() { set(ignore); type=3;}
63647                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
63648                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
63649                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63650                 template<typename V>  bool decode(V& v)
63651                 {
63652                         clear();
63653                         if(!v(ref_nested())) return false;
63654                         if(equal(ignore)) { type = 1; return true; }
63655                         else if(equal(ignore)) { type = 2; return true; }
63656                         else if(equal(ignore)) { type = 3; return true; }
63657                         else if(equal(ignore)) { type = 4; return true; }
63658                         else if(equal(ignore)) { type = 5; return true; }
63659                         else { type = 6; return true;}
63660                         return false;
63661
63662                 }
63663                 template<typename V> bool encode(V& v) const
63664                 {
63665                         return v(ref_nested());
63666
63667                 }
63668                 protected:
63669                 template<typename V>  bool decode(size_t index, V& v)
63670                 {
63671                         clear();
63672                         switch(index)
63673                         {
63674                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
63675                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
63676                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
63677                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
63678                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
63679                         case 6: type = 6; return v(ref_nested());
63680                         ref_nested().clear();
63681                         }
63682                         return false;
63683
63684                 }
63685                 template<typename V> bool encode(size_t index, V& v) const
63686                 {
63687                         if(index != type) {return false;} return v(ref_nested());
63688
63689                 }
63690                 private:
63691                 size_t type {0};
63692
63693         };
63694         struct Value_t : asn::typefield<true>
63695         {
63696                 ~Value_t()      {clear();}
63697                 size_t get_index() const {return type;}
63698                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
63699                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
63700                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
63701                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
63702                 Cause& select_id_Cause() { return set<Cause>(3); }
63703                 Cause const* get_id_Cause() const { return get<Cause>(3); }
63704                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
63705                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
63706                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
63707                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
63708                 bool is_unknown() const { return type == 6; }
63709                 void clear()
63710                 {
63711                         switch(type)
63712                         {
63713                         case 1: var.destroy<UE_X2AP_ID>(); break;
63714                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
63715                         case 3: var.destroy<Cause>(); break;
63716                         case 4: var.destroy<CriticalityDiagnostics>(); break;
63717                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
63718                         }
63719                         type = 0; ref_nested().clear();
63720                 }
63721                 template<typename V> static inline void enumerate(V& v)
63722                 {
63723                         v.template operator()<UE_X2AP_ID>(1);
63724                         v.template operator()<SgNB_UE_X2AP_ID>(2);
63725                         v.template operator()<Cause>(3);
63726                         v.template operator()<CriticalityDiagnostics>(4);
63727                         v.template operator()<UE_X2AP_ID_Extension>(5);
63728
63729                 }
63730                 protected:
63731                 template<typename V> bool decode(size_t index, V& v)
63732                 {
63733                         clear();
63734                         switch(index)
63735                         {
63736                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
63737                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
63738                         case 3: v(select_id_Cause()); return true;
63739                         case 4: v(select_id_CriticalityDiagnostics()); return true;
63740                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
63741                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
63742                         }
63743                         return false;
63744
63745                 }
63746                 template<typename V> bool encode(size_t index, V& v) const
63747                 {
63748                         if(index != type) return false;
63749                         switch(type)
63750                         {
63751                         case 1: v(var.as<UE_X2AP_ID>()); return true;
63752                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
63753                         case 3: v(var.as<Cause>()); return true;
63754                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
63755                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
63756                         }
63757                         return false;
63758
63759                 }
63760                 private:
63761                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
63762                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
63763                 union union_type
63764                 {
63765                         char dummy1[sizeof(Cause)];
63766                         char dummy2[sizeof(CriticalityDiagnostics)];
63767                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
63768                         char dummy4[sizeof(UE_X2AP_ID)];
63769                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
63770
63771                 };
63772                 asn::variant<sizeof(union_type)> var;
63773                 size_t type {0};
63774
63775         };
63776         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
63777         {
63778                 size_t get_index() const {return type;}
63779                 bool is_unknown() const { return type == 6; }
63780                 void clear() {type = 0;}
63781                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
63782                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
63783                 void select_id_Cause() { set(mandatory); type=3;}
63784                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
63785                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
63786                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
63787                 template<typename V>  bool decode(V& v)
63788                 {
63789                         clear();
63790                         if(!v(ref_nested())) return false;
63791                         if(equal(mandatory)) { type = 1; return true; }
63792                         else if(equal(mandatory)) { type = 2; return true; }
63793                         else if(equal(mandatory)) { type = 3; return true; }
63794                         else if(equal(optional)) { type = 4; return true; }
63795                         else if(equal(optional)) { type = 5; return true; }
63796                         else { type = 6; return true;}
63797                         return false;
63798
63799                 }
63800                 template<typename V> bool encode(V& v) const
63801                 {
63802                         return v(ref_nested());
63803
63804                 }
63805                 protected:
63806                 template<typename V>  bool decode(size_t index, V& v)
63807                 {
63808                         clear();
63809                         switch(index)
63810                         {
63811                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
63812                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
63813                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
63814                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
63815                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
63816                         case 6: type = 6; return v(ref_nested());
63817                         ref_nested().clear();
63818                         }
63819                         return false;
63820
63821                 }
63822                 template<typename V> bool encode(size_t index, V& v) const
63823                 {
63824                         if(index != type) {return false;} return v(ref_nested());
63825
63826                 }
63827                 private:
63828                 size_t type {0};
63829
63830         };
63831
63832 };
63833 /*
63834 SgNBModificationRequestReject ::= SEQUENCE {
63835         protocolIEs             ProtocolIE-Container    {{SgNBModificationRequestReject-IEs}},
63836         ...
63837 }
63838 */
63839
63840 struct SgNBModificationRequestReject : asn::sequence<1, 0, true, 0>
63841 {
63842         static constexpr const char* name() {return "SgNBModificationRequestReject";}
63843         using parent_t = asn::sequence<1, 0, true, 0>;
63844         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequestReject_IEs>
63845         {
63846                 static constexpr const char* name() {return "protocolIEs_t";}
63847                 using parent_t = ProtocolIE_Container<SgNBModificationRequestReject_IEs>;
63848
63849         };
63850         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
63851         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
63852         template<typename V> void decode(V& v)
63853         {
63854                 v(protocolIEs);
63855
63856         };
63857         template<typename V> void encode(V& v) const
63858         {
63859                 v(protocolIEs);
63860
63861         };
63862         void clear()
63863         {
63864                 protocolIEs.clear();
63865
63866         };
63867         private:
63868         protocolIEs_t   protocolIEs;
63869
63870 };
63871 /*
63872 SgNBModificationRequired-IEs X2AP-PROTOCOL-IES ::= {
63873         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
63874         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                            PRESENCE mandatory}|
63875         { ID id-Cause                                                                   CRITICALITY ignore      TYPE Cause                                                                                      PRESENCE mandatory}|
63876         { ID id-PDCPChangeIndication                                    CRITICALITY ignore      TYPE PDCPChangeIndication                                                       PRESENCE optional}|
63877         { ID id-E-RABs-ToBeReleased-SgNBModReqdList             CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBModReqdList                PRESENCE optional}|
63878         { ID id-SgNBtoMeNBContainer                                             CRITICALITY ignore      TYPE SgNBtoMeNBContainer                                                        PRESENCE optional}|
63879         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
63880         { ID id-E-RABs-ToBeModified-SgNBModReqdList             CRITICALITY ignore      TYPE E-RABs-ToBeModified-SgNBModReqdList                PRESENCE optional}|
63881         { ID id-SgNBResourceCoordinationInformation             CRITICALITY ignore      TYPE SgNBResourceCoordinationInformation                PRESENCE optional}|
63882         { ID id-RRCConfigIndication                                             CRITICALITY reject      TYPE RRC-Config-Ind                                                                     PRESENCE optional},
63883         ...
63884 }
63885 */
63886
63887 struct SgNBModificationRequired_IEs
63888 {
63889         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
63890         {
63891                 size_t get_index() const {return type;}
63892                 bool is_unknown() const { return type == 11; }
63893                 void clear() {type = 0;}
63894                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
63895                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
63896                 void select_id_Cause() { set(id_Cause); type=3;}
63897                 void select_id_PDCPChangeIndication() { set(id_PDCPChangeIndication); type=4;}
63898                 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(id_E_RABs_ToBeReleased_SgNBModReqdList); type=5;}
63899                 void select_id_SgNBtoMeNBContainer() { set(id_SgNBtoMeNBContainer); type=6;}
63900                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=7;}
63901                 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(id_E_RABs_ToBeModified_SgNBModReqdList); type=8;}
63902                 void select_id_SgNBResourceCoordinationInformation() { set(id_SgNBResourceCoordinationInformation); type=9;}
63903                 void select_id_RRCConfigIndication() { set(id_RRCConfigIndication); type=10;}
63904                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
63905                 template<typename V>  bool decode(V& v)
63906                 {
63907                         clear();
63908                         if(!v(ref_nested())) return false;
63909                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
63910                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
63911                         else if(equal(id_Cause)) { type = 3; return true; }
63912                         else if(equal(id_PDCPChangeIndication)) { type = 4; return true; }
63913                         else if(equal(id_E_RABs_ToBeReleased_SgNBModReqdList)) { type = 5; return true; }
63914                         else if(equal(id_SgNBtoMeNBContainer)) { type = 6; return true; }
63915                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 7; return true; }
63916                         else if(equal(id_E_RABs_ToBeModified_SgNBModReqdList)) { type = 8; return true; }
63917                         else if(equal(id_SgNBResourceCoordinationInformation)) { type = 9; return true; }
63918                         else if(equal(id_RRCConfigIndication)) { type = 10; return true; }
63919                         else { type = 11; return true;}
63920                         return false;
63921
63922                 }
63923                 template<typename V> bool encode(V& v) const
63924                 {
63925                         return v(ref_nested());
63926
63927                 }
63928                 protected:
63929                 template<typename V>  bool decode(size_t index, V& v)
63930                 {
63931                         clear();
63932                         switch(index)
63933                         {
63934                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
63935                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
63936                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
63937                         case 4: type = 4; if(v(ref_nested())) { return equal(id_PDCPChangeIndication);} return false;
63938                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBModReqdList);} return false;
63939                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNBtoMeNBContainer);} return false;
63940                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
63941                         case 8: type = 8; if(v(ref_nested())) { return equal(id_E_RABs_ToBeModified_SgNBModReqdList);} return false;
63942                         case 9: type = 9; if(v(ref_nested())) { return equal(id_SgNBResourceCoordinationInformation);} return false;
63943                         case 10: type = 10; if(v(ref_nested())) { return equal(id_RRCConfigIndication);} return false;
63944                         case 11: type = 11; return v(ref_nested());
63945                         ref_nested().clear();
63946                         }
63947                         return false;
63948
63949                 }
63950                 template<typename V> bool encode(size_t index, V& v) const
63951                 {
63952                         if(index != type) {return false;} return v(ref_nested());
63953
63954                 }
63955                 private:
63956                 size_t type {0};
63957
63958         };
63959         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
63960         {
63961                 size_t get_index() const {return type;}
63962                 bool is_unknown() const { return type == 11; }
63963                 void clear() {type = 0;}
63964                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
63965                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
63966                 void select_id_Cause() { set(ignore); type=3;}
63967                 void select_id_PDCPChangeIndication() { set(ignore); type=4;}
63968                 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(ignore); type=5;}
63969                 void select_id_SgNBtoMeNBContainer() { set(ignore); type=6;}
63970                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=7;}
63971                 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(ignore); type=8;}
63972                 void select_id_SgNBResourceCoordinationInformation() { set(ignore); type=9;}
63973                 void select_id_RRCConfigIndication() { set(reject); type=10;}
63974                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
63975                 template<typename V>  bool decode(V& v)
63976                 {
63977                         clear();
63978                         if(!v(ref_nested())) return false;
63979                         if(equal(reject)) { type = 1; return true; }
63980                         else if(equal(reject)) { type = 2; return true; }
63981                         else if(equal(ignore)) { type = 3; return true; }
63982                         else if(equal(ignore)) { type = 4; return true; }
63983                         else if(equal(ignore)) { type = 5; return true; }
63984                         else if(equal(ignore)) { type = 6; return true; }
63985                         else if(equal(reject)) { type = 7; return true; }
63986                         else if(equal(ignore)) { type = 8; return true; }
63987                         else if(equal(ignore)) { type = 9; return true; }
63988                         else if(equal(reject)) { type = 10; return true; }
63989                         else { type = 11; return true;}
63990                         return false;
63991
63992                 }
63993                 template<typename V> bool encode(V& v) const
63994                 {
63995                         return v(ref_nested());
63996
63997                 }
63998                 protected:
63999                 template<typename V>  bool decode(size_t index, V& v)
64000                 {
64001                         clear();
64002                         switch(index)
64003                         {
64004                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64005                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64006                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64007                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64008                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64009                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
64010                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
64011                         case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
64012                         case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
64013                         case 10: type = 10; if(v(ref_nested())) { return equal(reject);} return false;
64014                         case 11: type = 11; return v(ref_nested());
64015                         ref_nested().clear();
64016                         }
64017                         return false;
64018
64019                 }
64020                 template<typename V> bool encode(size_t index, V& v) const
64021                 {
64022                         if(index != type) {return false;} return v(ref_nested());
64023
64024                 }
64025                 private:
64026                 size_t type {0};
64027
64028         };
64029         struct Value_t : asn::typefield<true>
64030         {
64031                 ~Value_t()      {clear();}
64032                 size_t get_index() const {return type;}
64033                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64034                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64035                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64036                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64037                 Cause& select_id_Cause() { return set<Cause>(3); }
64038                 Cause const* get_id_Cause() const { return get<Cause>(3); }
64039                 PDCPChangeIndication& select_id_PDCPChangeIndication() { return set<PDCPChangeIndication>(4); }
64040                 PDCPChangeIndication const* get_id_PDCPChangeIndication() const { return get<PDCPChangeIndication>(4); }
64041                 E_RABs_ToBeReleased_SgNBModReqdList& select_id_E_RABs_ToBeReleased_SgNBModReqdList() { return set<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
64042                 E_RABs_ToBeReleased_SgNBModReqdList const* get_id_E_RABs_ToBeReleased_SgNBModReqdList() const { return get<E_RABs_ToBeReleased_SgNBModReqdList>(5); }
64043                 SgNBtoMeNBContainer& select_id_SgNBtoMeNBContainer() { return set<SgNBtoMeNBContainer>(6); }
64044                 SgNBtoMeNBContainer const* get_id_SgNBtoMeNBContainer() const { return get<SgNBtoMeNBContainer>(6); }
64045                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(7); }
64046                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(7); }
64047                 E_RABs_ToBeModified_SgNBModReqdList& select_id_E_RABs_ToBeModified_SgNBModReqdList() { return set<E_RABs_ToBeModified_SgNBModReqdList>(8); }
64048                 E_RABs_ToBeModified_SgNBModReqdList const* get_id_E_RABs_ToBeModified_SgNBModReqdList() const { return get<E_RABs_ToBeModified_SgNBModReqdList>(8); }
64049                 SgNBResourceCoordinationInformation& select_id_SgNBResourceCoordinationInformation() { return set<SgNBResourceCoordinationInformation>(9); }
64050                 SgNBResourceCoordinationInformation const* get_id_SgNBResourceCoordinationInformation() const { return get<SgNBResourceCoordinationInformation>(9); }
64051                 RRC_Config_Ind& select_id_RRCConfigIndication() { return set<RRC_Config_Ind>(10); }
64052                 RRC_Config_Ind const* get_id_RRCConfigIndication() const { return get<RRC_Config_Ind>(10); }
64053                 bool is_unknown() const { return type == 11; }
64054                 void clear()
64055                 {
64056                         switch(type)
64057                         {
64058                         case 1: var.destroy<UE_X2AP_ID>(); break;
64059                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64060                         case 3: var.destroy<Cause>(); break;
64061                         case 4: var.destroy<PDCPChangeIndication>(); break;
64062                         case 5: var.destroy<E_RABs_ToBeReleased_SgNBModReqdList>(); break;
64063                         case 6: var.destroy<SgNBtoMeNBContainer>(); break;
64064                         case 7: var.destroy<UE_X2AP_ID_Extension>(); break;
64065                         case 8: var.destroy<E_RABs_ToBeModified_SgNBModReqdList>(); break;
64066                         case 9: var.destroy<SgNBResourceCoordinationInformation>(); break;
64067                         case 10: var.destroy<RRC_Config_Ind>(); break;
64068                         }
64069                         type = 0; ref_nested().clear();
64070                 }
64071                 template<typename V> static inline void enumerate(V& v)
64072                 {
64073                         v.template operator()<UE_X2AP_ID>(1);
64074                         v.template operator()<SgNB_UE_X2AP_ID>(2);
64075                         v.template operator()<Cause>(3);
64076                         v.template operator()<PDCPChangeIndication>(4);
64077                         v.template operator()<E_RABs_ToBeReleased_SgNBModReqdList>(5);
64078                         v.template operator()<SgNBtoMeNBContainer>(6);
64079                         v.template operator()<UE_X2AP_ID_Extension>(7);
64080                         v.template operator()<E_RABs_ToBeModified_SgNBModReqdList>(8);
64081                         v.template operator()<SgNBResourceCoordinationInformation>(9);
64082                         v.template operator()<RRC_Config_Ind>(10);
64083
64084                 }
64085                 protected:
64086                 template<typename V> bool decode(size_t index, V& v)
64087                 {
64088                         clear();
64089                         switch(index)
64090                         {
64091                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64092                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64093                         case 3: v(select_id_Cause()); return true;
64094                         case 4: v(select_id_PDCPChangeIndication()); return true;
64095                         case 5: v(select_id_E_RABs_ToBeReleased_SgNBModReqdList()); return true;
64096                         case 6: v(select_id_SgNBtoMeNBContainer()); return true;
64097                         case 7: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64098                         case 8: v(select_id_E_RABs_ToBeModified_SgNBModReqdList()); return true;
64099                         case 9: v(select_id_SgNBResourceCoordinationInformation()); return true;
64100                         case 10: v(select_id_RRCConfigIndication()); return true;
64101                         case 11: if(type != 11) {clear(); asn::base::set();} type = 11; return true;
64102                         }
64103                         return false;
64104
64105                 }
64106                 template<typename V> bool encode(size_t index, V& v) const
64107                 {
64108                         if(index != type) return false;
64109                         switch(type)
64110                         {
64111                         case 1: v(var.as<UE_X2AP_ID>()); return true;
64112                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64113                         case 3: v(var.as<Cause>()); return true;
64114                         case 4: v(var.as<PDCPChangeIndication>()); return true;
64115                         case 5: v(var.as<E_RABs_ToBeReleased_SgNBModReqdList>()); return true;
64116                         case 6: v(var.as<SgNBtoMeNBContainer>()); return true;
64117                         case 7: v(var.as<UE_X2AP_ID_Extension>()); return true;
64118                         case 8: v(var.as<E_RABs_ToBeModified_SgNBModReqdList>()); return true;
64119                         case 9: v(var.as<SgNBResourceCoordinationInformation>()); return true;
64120                         case 10: v(var.as<RRC_Config_Ind>()); return true;
64121                         }
64122                         return false;
64123
64124                 }
64125                 private:
64126                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64127                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64128                 union union_type
64129                 {
64130                         char dummy1[sizeof(Cause)];
64131                         char dummy2[sizeof(E_RABs_ToBeModified_SgNBModReqdList)];
64132                         char dummy3[sizeof(E_RABs_ToBeReleased_SgNBModReqdList)];
64133                         char dummy4[sizeof(PDCPChangeIndication)];
64134                         char dummy5[sizeof(RRC_Config_Ind)];
64135                         char dummy6[sizeof(SgNBResourceCoordinationInformation)];
64136                         char dummy7[sizeof(SgNB_UE_X2AP_ID)];
64137                         char dummy8[sizeof(SgNBtoMeNBContainer)];
64138                         char dummy9[sizeof(UE_X2AP_ID)];
64139                         char dummy10[sizeof(UE_X2AP_ID_Extension)];
64140
64141                 };
64142                 asn::variant<sizeof(union_type)> var;
64143                 size_t type {0};
64144
64145         };
64146         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64147         {
64148                 size_t get_index() const {return type;}
64149                 bool is_unknown() const { return type == 11; }
64150                 void clear() {type = 0;}
64151                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64152                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64153                 void select_id_Cause() { set(mandatory); type=3;}
64154                 void select_id_PDCPChangeIndication() { set(optional); type=4;}
64155                 void select_id_E_RABs_ToBeReleased_SgNBModReqdList() { set(optional); type=5;}
64156                 void select_id_SgNBtoMeNBContainer() { set(optional); type=6;}
64157                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=7;}
64158                 void select_id_E_RABs_ToBeModified_SgNBModReqdList() { set(optional); type=8;}
64159                 void select_id_SgNBResourceCoordinationInformation() { set(optional); type=9;}
64160                 void select_id_RRCConfigIndication() { set(optional); type=10;}
64161                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64162                 template<typename V>  bool decode(V& v)
64163                 {
64164                         clear();
64165                         if(!v(ref_nested())) return false;
64166                         if(equal(mandatory)) { type = 1; return true; }
64167                         else if(equal(mandatory)) { type = 2; return true; }
64168                         else if(equal(mandatory)) { type = 3; return true; }
64169                         else if(equal(optional)) { type = 4; return true; }
64170                         else if(equal(optional)) { type = 5; return true; }
64171                         else if(equal(optional)) { type = 6; return true; }
64172                         else if(equal(optional)) { type = 7; return true; }
64173                         else if(equal(optional)) { type = 8; return true; }
64174                         else if(equal(optional)) { type = 9; return true; }
64175                         else if(equal(optional)) { type = 10; return true; }
64176                         else { type = 11; return true;}
64177                         return false;
64178
64179                 }
64180                 template<typename V> bool encode(V& v) const
64181                 {
64182                         return v(ref_nested());
64183
64184                 }
64185                 protected:
64186                 template<typename V>  bool decode(size_t index, V& v)
64187                 {
64188                         clear();
64189                         switch(index)
64190                         {
64191                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64192                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64193                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
64194                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64195                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
64196                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
64197                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
64198                         case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
64199                         case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
64200                         case 10: type = 10; if(v(ref_nested())) { return equal(optional);} return false;
64201                         case 11: type = 11; return v(ref_nested());
64202                         ref_nested().clear();
64203                         }
64204                         return false;
64205
64206                 }
64207                 template<typename V> bool encode(size_t index, V& v) const
64208                 {
64209                         if(index != type) {return false;} return v(ref_nested());
64210
64211                 }
64212                 private:
64213                 size_t type {0};
64214
64215         };
64216
64217 };
64218 /*
64219 SgNBModificationRequired ::= SEQUENCE {
64220         protocolIEs             ProtocolIE-Container            {{SgNBModificationRequired-IEs}},
64221         ...
64222 }
64223 */
64224
64225 struct SgNBModificationRequired : asn::sequence<1, 0, true, 0>
64226 {
64227         static constexpr const char* name() {return "SgNBModificationRequired";}
64228         using parent_t = asn::sequence<1, 0, true, 0>;
64229         struct protocolIEs_t : ProtocolIE_Container<SgNBModificationRequired_IEs>
64230         {
64231                 static constexpr const char* name() {return "protocolIEs_t";}
64232                 using parent_t = ProtocolIE_Container<SgNBModificationRequired_IEs>;
64233
64234         };
64235         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64236         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64237         template<typename V> void decode(V& v)
64238         {
64239                 v(protocolIEs);
64240
64241         };
64242         template<typename V> void encode(V& v) const
64243         {
64244                 v(protocolIEs);
64245
64246         };
64247         void clear()
64248         {
64249                 protocolIEs.clear();
64250
64251         };
64252         private:
64253         protocolIEs_t   protocolIEs;
64254
64255 };
64256 /*
64257 SgNBReconfigurationComplete-IEs X2AP-PROTOCOL-IES ::= {
64258         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
64259         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE mandatory}|
64260         { ID id-ResponseInformationSgNBReconfComp               CRITICALITY ignore      TYPE ResponseInformationSgNBReconfComp                  PRESENCE mandatory}|
64261         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                               PRESENCE optional},
64262         ...
64263 }
64264 */
64265
64266 struct SgNBReconfigurationComplete_IEs
64267 {
64268         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64269         {
64270                 size_t get_index() const {return type;}
64271                 bool is_unknown() const { return type == 5; }
64272                 void clear() {type = 0;}
64273                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64274                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64275                 void select_id_ResponseInformationSgNBReconfComp() { set(id_ResponseInformationSgNBReconfComp); type=3;}
64276                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
64277                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64278                 template<typename V>  bool decode(V& v)
64279                 {
64280                         clear();
64281                         if(!v(ref_nested())) return false;
64282                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64283                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64284                         else if(equal(id_ResponseInformationSgNBReconfComp)) { type = 3; return true; }
64285                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
64286                         else { type = 5; return true;}
64287                         return false;
64288
64289                 }
64290                 template<typename V> bool encode(V& v) const
64291                 {
64292                         return v(ref_nested());
64293
64294                 }
64295                 protected:
64296                 template<typename V>  bool decode(size_t index, V& v)
64297                 {
64298                         clear();
64299                         switch(index)
64300                         {
64301                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64302                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64303                         case 3: type = 3; if(v(ref_nested())) { return equal(id_ResponseInformationSgNBReconfComp);} return false;
64304                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64305                         case 5: type = 5; return v(ref_nested());
64306                         ref_nested().clear();
64307                         }
64308                         return false;
64309
64310                 }
64311                 template<typename V> bool encode(size_t index, V& v) const
64312                 {
64313                         if(index != type) {return false;} return v(ref_nested());
64314
64315                 }
64316                 private:
64317                 size_t type {0};
64318
64319         };
64320         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64321         {
64322                 size_t get_index() const {return type;}
64323                 bool is_unknown() const { return type == 5; }
64324                 void clear() {type = 0;}
64325                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
64326                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
64327                 void select_id_ResponseInformationSgNBReconfComp() { set(ignore); type=3;}
64328                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
64329                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64330                 template<typename V>  bool decode(V& v)
64331                 {
64332                         clear();
64333                         if(!v(ref_nested())) return false;
64334                         if(equal(reject)) { type = 1; return true; }
64335                         else if(equal(reject)) { type = 2; return true; }
64336                         else if(equal(ignore)) { type = 3; return true; }
64337                         else if(equal(reject)) { type = 4; return true; }
64338                         else { type = 5; return true;}
64339                         return false;
64340
64341                 }
64342                 template<typename V> bool encode(V& v) const
64343                 {
64344                         return v(ref_nested());
64345
64346                 }
64347                 protected:
64348                 template<typename V>  bool decode(size_t index, V& v)
64349                 {
64350                         clear();
64351                         switch(index)
64352                         {
64353                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64354                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64355                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64356                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
64357                         case 5: type = 5; return v(ref_nested());
64358                         ref_nested().clear();
64359                         }
64360                         return false;
64361
64362                 }
64363                 template<typename V> bool encode(size_t index, V& v) const
64364                 {
64365                         if(index != type) {return false;} return v(ref_nested());
64366
64367                 }
64368                 private:
64369                 size_t type {0};
64370
64371         };
64372         struct Value_t : asn::typefield<true>
64373         {
64374                 ~Value_t()      {clear();}
64375                 size_t get_index() const {return type;}
64376                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64377                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64378                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64379                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64380                 ResponseInformationSgNBReconfComp& select_id_ResponseInformationSgNBReconfComp() { return set<ResponseInformationSgNBReconfComp>(3); }
64381                 ResponseInformationSgNBReconfComp const* get_id_ResponseInformationSgNBReconfComp() const { return get<ResponseInformationSgNBReconfComp>(3); }
64382                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
64383                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
64384                 bool is_unknown() const { return type == 5; }
64385                 void clear()
64386                 {
64387                         switch(type)
64388                         {
64389                         case 1: var.destroy<UE_X2AP_ID>(); break;
64390                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64391                         case 3: var.destroy<ResponseInformationSgNBReconfComp>(); break;
64392                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
64393                         }
64394                         type = 0; ref_nested().clear();
64395                 }
64396                 template<typename V> static inline void enumerate(V& v)
64397                 {
64398                         v.template operator()<UE_X2AP_ID>(1);
64399                         v.template operator()<SgNB_UE_X2AP_ID>(2);
64400                         v.template operator()<ResponseInformationSgNBReconfComp>(3);
64401                         v.template operator()<UE_X2AP_ID_Extension>(4);
64402
64403                 }
64404                 protected:
64405                 template<typename V> bool decode(size_t index, V& v)
64406                 {
64407                         clear();
64408                         switch(index)
64409                         {
64410                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64411                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64412                         case 3: v(select_id_ResponseInformationSgNBReconfComp()); return true;
64413                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64414                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
64415                         }
64416                         return false;
64417
64418                 }
64419                 template<typename V> bool encode(size_t index, V& v) const
64420                 {
64421                         if(index != type) return false;
64422                         switch(type)
64423                         {
64424                         case 1: v(var.as<UE_X2AP_ID>()); return true;
64425                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64426                         case 3: v(var.as<ResponseInformationSgNBReconfComp>()); return true;
64427                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
64428                         }
64429                         return false;
64430
64431                 }
64432                 private:
64433                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64434                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64435                 union union_type
64436                 {
64437                         char dummy1[sizeof(ResponseInformationSgNBReconfComp)];
64438                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
64439                         char dummy3[sizeof(UE_X2AP_ID)];
64440                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
64441
64442                 };
64443                 asn::variant<sizeof(union_type)> var;
64444                 size_t type {0};
64445
64446         };
64447         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64448         {
64449                 size_t get_index() const {return type;}
64450                 bool is_unknown() const { return type == 5; }
64451                 void clear() {type = 0;}
64452                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64453                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64454                 void select_id_ResponseInformationSgNBReconfComp() { set(mandatory); type=3;}
64455                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
64456                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64457                 template<typename V>  bool decode(V& v)
64458                 {
64459                         clear();
64460                         if(!v(ref_nested())) return false;
64461                         if(equal(mandatory)) { type = 1; return true; }
64462                         else if(equal(mandatory)) { type = 2; return true; }
64463                         else if(equal(mandatory)) { type = 3; return true; }
64464                         else if(equal(optional)) { type = 4; return true; }
64465                         else { type = 5; return true;}
64466                         return false;
64467
64468                 }
64469                 template<typename V> bool encode(V& v) const
64470                 {
64471                         return v(ref_nested());
64472
64473                 }
64474                 protected:
64475                 template<typename V>  bool decode(size_t index, V& v)
64476                 {
64477                         clear();
64478                         switch(index)
64479                         {
64480                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64481                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64482                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
64483                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64484                         case 5: type = 5; return v(ref_nested());
64485                         ref_nested().clear();
64486                         }
64487                         return false;
64488
64489                 }
64490                 template<typename V> bool encode(size_t index, V& v) const
64491                 {
64492                         if(index != type) {return false;} return v(ref_nested());
64493
64494                 }
64495                 private:
64496                 size_t type {0};
64497
64498         };
64499
64500 };
64501 /*
64502 SgNBReconfigurationComplete ::= SEQUENCE {
64503         protocolIEs             ProtocolIE-Container    {{SgNBReconfigurationComplete-IEs}},
64504         ...
64505 }
64506 */
64507
64508 struct SgNBReconfigurationComplete : asn::sequence<1, 0, true, 0>
64509 {
64510         static constexpr const char* name() {return "SgNBReconfigurationComplete";}
64511         using parent_t = asn::sequence<1, 0, true, 0>;
64512         struct protocolIEs_t : ProtocolIE_Container<SgNBReconfigurationComplete_IEs>
64513         {
64514                 static constexpr const char* name() {return "protocolIEs_t";}
64515                 using parent_t = ProtocolIE_Container<SgNBReconfigurationComplete_IEs>;
64516
64517         };
64518         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64519         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64520         template<typename V> void decode(V& v)
64521         {
64522                 v(protocolIEs);
64523
64524         };
64525         template<typename V> void encode(V& v) const
64526         {
64527                 v(protocolIEs);
64528
64529         };
64530         void clear()
64531         {
64532                 protocolIEs.clear();
64533
64534         };
64535         private:
64536         protocolIEs_t   protocolIEs;
64537
64538 };
64539 /*
64540 SgNBReleaseConfirm-IEs X2AP-PROTOCOL-IES ::= {
64541         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
64542         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE mandatory}|
64543         { ID id-E-RABs-ToBeReleased-SgNBRelConfList             CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBRelConfList                PRESENCE optional}|
64544         { ID id-CriticalityDiagnostics                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional}|
64545         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY ignore      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional},
64546         ...
64547 }
64548 */
64549
64550 struct SgNBReleaseConfirm_IEs
64551 {
64552         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64553         {
64554                 size_t get_index() const {return type;}
64555                 bool is_unknown() const { return type == 6; }
64556                 void clear() {type = 0;}
64557                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64558                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64559                 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(id_E_RABs_ToBeReleased_SgNBRelConfList); type=3;}
64560                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
64561                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
64562                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64563                 template<typename V>  bool decode(V& v)
64564                 {
64565                         clear();
64566                         if(!v(ref_nested())) return false;
64567                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64568                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64569                         else if(equal(id_E_RABs_ToBeReleased_SgNBRelConfList)) { type = 3; return true; }
64570                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
64571                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
64572                         else { type = 6; return true;}
64573                         return false;
64574
64575                 }
64576                 template<typename V> bool encode(V& v) const
64577                 {
64578                         return v(ref_nested());
64579
64580                 }
64581                 protected:
64582                 template<typename V>  bool decode(size_t index, V& v)
64583                 {
64584                         clear();
64585                         switch(index)
64586                         {
64587                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64588                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64589                         case 3: type = 3; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelConfList);} return false;
64590                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
64591                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64592                         case 6: type = 6; return v(ref_nested());
64593                         ref_nested().clear();
64594                         }
64595                         return false;
64596
64597                 }
64598                 template<typename V> bool encode(size_t index, V& v) const
64599                 {
64600                         if(index != type) {return false;} return v(ref_nested());
64601
64602                 }
64603                 private:
64604                 size_t type {0};
64605
64606         };
64607         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64608         {
64609                 size_t get_index() const {return type;}
64610                 bool is_unknown() const { return type == 6; }
64611                 void clear() {type = 0;}
64612                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
64613                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
64614                 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(ignore); type=3;}
64615                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
64616                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(ignore); type=5;}
64617                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64618                 template<typename V>  bool decode(V& v)
64619                 {
64620                         clear();
64621                         if(!v(ref_nested())) return false;
64622                         if(equal(ignore)) { type = 1; return true; }
64623                         else if(equal(ignore)) { type = 2; return true; }
64624                         else if(equal(ignore)) { type = 3; return true; }
64625                         else if(equal(ignore)) { type = 4; return true; }
64626                         else if(equal(ignore)) { type = 5; return true; }
64627                         else { type = 6; return true;}
64628                         return false;
64629
64630                 }
64631                 template<typename V> bool encode(V& v) const
64632                 {
64633                         return v(ref_nested());
64634
64635                 }
64636                 protected:
64637                 template<typename V>  bool decode(size_t index, V& v)
64638                 {
64639                         clear();
64640                         switch(index)
64641                         {
64642                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
64643                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
64644                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64645                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64646                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64647                         case 6: type = 6; return v(ref_nested());
64648                         ref_nested().clear();
64649                         }
64650                         return false;
64651
64652                 }
64653                 template<typename V> bool encode(size_t index, V& v) const
64654                 {
64655                         if(index != type) {return false;} return v(ref_nested());
64656
64657                 }
64658                 private:
64659                 size_t type {0};
64660
64661         };
64662         struct Value_t : asn::typefield<true>
64663         {
64664                 ~Value_t()      {clear();}
64665                 size_t get_index() const {return type;}
64666                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64667                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64668                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64669                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64670                 E_RABs_ToBeReleased_SgNBRelConfList& select_id_E_RABs_ToBeReleased_SgNBRelConfList() { return set<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
64671                 E_RABs_ToBeReleased_SgNBRelConfList const* get_id_E_RABs_ToBeReleased_SgNBRelConfList() const { return get<E_RABs_ToBeReleased_SgNBRelConfList>(3); }
64672                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
64673                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
64674                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
64675                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
64676                 bool is_unknown() const { return type == 6; }
64677                 void clear()
64678                 {
64679                         switch(type)
64680                         {
64681                         case 1: var.destroy<UE_X2AP_ID>(); break;
64682                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
64683                         case 3: var.destroy<E_RABs_ToBeReleased_SgNBRelConfList>(); break;
64684                         case 4: var.destroy<CriticalityDiagnostics>(); break;
64685                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
64686                         }
64687                         type = 0; ref_nested().clear();
64688                 }
64689                 template<typename V> static inline void enumerate(V& v)
64690                 {
64691                         v.template operator()<UE_X2AP_ID>(1);
64692                         v.template operator()<SgNB_UE_X2AP_ID>(2);
64693                         v.template operator()<E_RABs_ToBeReleased_SgNBRelConfList>(3);
64694                         v.template operator()<CriticalityDiagnostics>(4);
64695                         v.template operator()<UE_X2AP_ID_Extension>(5);
64696
64697                 }
64698                 protected:
64699                 template<typename V> bool decode(size_t index, V& v)
64700                 {
64701                         clear();
64702                         switch(index)
64703                         {
64704                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
64705                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
64706                         case 3: v(select_id_E_RABs_ToBeReleased_SgNBRelConfList()); return true;
64707                         case 4: v(select_id_CriticalityDiagnostics()); return true;
64708                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
64709                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
64710                         }
64711                         return false;
64712
64713                 }
64714                 template<typename V> bool encode(size_t index, V& v) const
64715                 {
64716                         if(index != type) return false;
64717                         switch(type)
64718                         {
64719                         case 1: v(var.as<UE_X2AP_ID>()); return true;
64720                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
64721                         case 3: v(var.as<E_RABs_ToBeReleased_SgNBRelConfList>()); return true;
64722                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
64723                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
64724                         }
64725                         return false;
64726
64727                 }
64728                 private:
64729                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
64730                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
64731                 union union_type
64732                 {
64733                         char dummy1[sizeof(CriticalityDiagnostics)];
64734                         char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelConfList)];
64735                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
64736                         char dummy4[sizeof(UE_X2AP_ID)];
64737                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
64738
64739                 };
64740                 asn::variant<sizeof(union_type)> var;
64741                 size_t type {0};
64742
64743         };
64744         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
64745         {
64746                 size_t get_index() const {return type;}
64747                 bool is_unknown() const { return type == 6; }
64748                 void clear() {type = 0;}
64749                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
64750                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
64751                 void select_id_E_RABs_ToBeReleased_SgNBRelConfList() { set(optional); type=3;}
64752                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
64753                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
64754                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
64755                 template<typename V>  bool decode(V& v)
64756                 {
64757                         clear();
64758                         if(!v(ref_nested())) return false;
64759                         if(equal(mandatory)) { type = 1; return true; }
64760                         else if(equal(mandatory)) { type = 2; return true; }
64761                         else if(equal(optional)) { type = 3; return true; }
64762                         else if(equal(optional)) { type = 4; return true; }
64763                         else if(equal(optional)) { type = 5; return true; }
64764                         else { type = 6; return true;}
64765                         return false;
64766
64767                 }
64768                 template<typename V> bool encode(V& v) const
64769                 {
64770                         return v(ref_nested());
64771
64772                 }
64773                 protected:
64774                 template<typename V>  bool decode(size_t index, V& v)
64775                 {
64776                         clear();
64777                         switch(index)
64778                         {
64779                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
64780                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
64781                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
64782                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
64783                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
64784                         case 6: type = 6; return v(ref_nested());
64785                         ref_nested().clear();
64786                         }
64787                         return false;
64788
64789                 }
64790                 template<typename V> bool encode(size_t index, V& v) const
64791                 {
64792                         if(index != type) {return false;} return v(ref_nested());
64793
64794                 }
64795                 private:
64796                 size_t type {0};
64797
64798         };
64799
64800 };
64801 /*
64802 SgNBReleaseConfirm ::= SEQUENCE {
64803         protocolIEs             ProtocolIE-Container    {{SgNBReleaseConfirm-IEs}},
64804         ...
64805 }
64806 */
64807
64808 struct SgNBReleaseConfirm : asn::sequence<1, 0, true, 0>
64809 {
64810         static constexpr const char* name() {return "SgNBReleaseConfirm";}
64811         using parent_t = asn::sequence<1, 0, true, 0>;
64812         struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseConfirm_IEs>
64813         {
64814                 static constexpr const char* name() {return "protocolIEs_t";}
64815                 using parent_t = ProtocolIE_Container<SgNBReleaseConfirm_IEs>;
64816
64817         };
64818         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
64819         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
64820         template<typename V> void decode(V& v)
64821         {
64822                 v(protocolIEs);
64823
64824         };
64825         template<typename V> void encode(V& v) const
64826         {
64827                 v(protocolIEs);
64828
64829         };
64830         void clear()
64831         {
64832                 protocolIEs.clear();
64833
64834         };
64835         private:
64836         protocolIEs_t   protocolIEs;
64837
64838 };
64839 /*
64840 SgNBReleaseRequest-IEs X2AP-PROTOCOL-IES ::= {
64841         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
64842         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE optional}|
64843         { ID id-Cause                                                                   CRITICALITY ignore      TYPE Cause                                                                                      PRESENCE mandatory}|
64844         { ID id-E-RABs-ToBeReleased-SgNBRelReqList              CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBRelReqList         PRESENCE optional}|
64845         { ID id-UE-ContextKeptIndicator                                 CRITICALITY ignore      TYPE UE-ContextKeptIndicator                                            PRESENCE optional}|
64846         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional}|
64847         { ID id-MeNBtoSgNBContainer                                             CRITICALITY reject      TYPE MeNBtoSgNBContainer                                                                PRESENCE optional},
64848         ...
64849 }
64850 */
64851
64852 struct SgNBReleaseRequest_IEs
64853 {
64854         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
64855         {
64856                 size_t get_index() const {return type;}
64857                 bool is_unknown() const { return type == 8; }
64858                 void clear() {type = 0;}
64859                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
64860                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
64861                 void select_id_Cause() { set(id_Cause); type=3;}
64862                 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(id_E_RABs_ToBeReleased_SgNBRelReqList); type=4;}
64863                 void select_id_UE_ContextKeptIndicator() { set(id_UE_ContextKeptIndicator); type=5;}
64864                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=6;}
64865                 void select_id_MeNBtoSgNBContainer() { set(id_MeNBtoSgNBContainer); type=7;}
64866                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
64867                 template<typename V>  bool decode(V& v)
64868                 {
64869                         clear();
64870                         if(!v(ref_nested())) return false;
64871                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
64872                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
64873                         else if(equal(id_Cause)) { type = 3; return true; }
64874                         else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqList)) { type = 4; return true; }
64875                         else if(equal(id_UE_ContextKeptIndicator)) { type = 5; return true; }
64876                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 6; return true; }
64877                         else if(equal(id_MeNBtoSgNBContainer)) { type = 7; return true; }
64878                         else { type = 8; return true;}
64879                         return false;
64880
64881                 }
64882                 template<typename V> bool encode(V& v) const
64883                 {
64884                         return v(ref_nested());
64885
64886                 }
64887                 protected:
64888                 template<typename V>  bool decode(size_t index, V& v)
64889                 {
64890                         clear();
64891                         switch(index)
64892                         {
64893                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
64894                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
64895                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
64896                         case 4: type = 4; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqList);} return false;
64897                         case 5: type = 5; if(v(ref_nested())) { return equal(id_UE_ContextKeptIndicator);} return false;
64898                         case 6: type = 6; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
64899                         case 7: type = 7; if(v(ref_nested())) { return equal(id_MeNBtoSgNBContainer);} return false;
64900                         case 8: type = 8; return v(ref_nested());
64901                         ref_nested().clear();
64902                         }
64903                         return false;
64904
64905                 }
64906                 template<typename V> bool encode(size_t index, V& v) const
64907                 {
64908                         if(index != type) {return false;} return v(ref_nested());
64909
64910                 }
64911                 private:
64912                 size_t type {0};
64913
64914         };
64915         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
64916         {
64917                 size_t get_index() const {return type;}
64918                 bool is_unknown() const { return type == 8; }
64919                 void clear() {type = 0;}
64920                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
64921                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
64922                 void select_id_Cause() { set(ignore); type=3;}
64923                 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(ignore); type=4;}
64924                 void select_id_UE_ContextKeptIndicator() { set(ignore); type=5;}
64925                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=6;}
64926                 void select_id_MeNBtoSgNBContainer() { set(reject); type=7;}
64927                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
64928                 template<typename V>  bool decode(V& v)
64929                 {
64930                         clear();
64931                         if(!v(ref_nested())) return false;
64932                         if(equal(reject)) { type = 1; return true; }
64933                         else if(equal(reject)) { type = 2; return true; }
64934                         else if(equal(ignore)) { type = 3; return true; }
64935                         else if(equal(ignore)) { type = 4; return true; }
64936                         else if(equal(ignore)) { type = 5; return true; }
64937                         else if(equal(reject)) { type = 6; return true; }
64938                         else if(equal(reject)) { type = 7; return true; }
64939                         else { type = 8; return true;}
64940                         return false;
64941
64942                 }
64943                 template<typename V> bool encode(V& v) const
64944                 {
64945                         return v(ref_nested());
64946
64947                 }
64948                 protected:
64949                 template<typename V>  bool decode(size_t index, V& v)
64950                 {
64951                         clear();
64952                         switch(index)
64953                         {
64954                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
64955                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
64956                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
64957                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
64958                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
64959                         case 6: type = 6; if(v(ref_nested())) { return equal(reject);} return false;
64960                         case 7: type = 7; if(v(ref_nested())) { return equal(reject);} return false;
64961                         case 8: type = 8; return v(ref_nested());
64962                         ref_nested().clear();
64963                         }
64964                         return false;
64965
64966                 }
64967                 template<typename V> bool encode(size_t index, V& v) const
64968                 {
64969                         if(index != type) {return false;} return v(ref_nested());
64970
64971                 }
64972                 private:
64973                 size_t type {0};
64974
64975         };
64976         struct Value_t : asn::typefield<true>
64977         {
64978                 ~Value_t()      {clear();}
64979                 size_t get_index() const {return type;}
64980                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
64981                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
64982                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
64983                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
64984                 Cause& select_id_Cause() { return set<Cause>(3); }
64985                 Cause const* get_id_Cause() const { return get<Cause>(3); }
64986                 E_RABs_ToBeReleased_SgNBRelReqList& select_id_E_RABs_ToBeReleased_SgNBRelReqList() { return set<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
64987                 E_RABs_ToBeReleased_SgNBRelReqList const* get_id_E_RABs_ToBeReleased_SgNBRelReqList() const { return get<E_RABs_ToBeReleased_SgNBRelReqList>(4); }
64988                 UE_ContextKeptIndicator& select_id_UE_ContextKeptIndicator() { return set<UE_ContextKeptIndicator>(5); }
64989                 UE_ContextKeptIndicator const* get_id_UE_ContextKeptIndicator() const { return get<UE_ContextKeptIndicator>(5); }
64990                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(6); }
64991                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(6); }
64992                 MeNBtoSgNBContainer& select_id_MeNBtoSgNBContainer() { return set<MeNBtoSgNBContainer>(7); }
64993                 MeNBtoSgNBContainer const* get_id_MeNBtoSgNBContainer() const { return get<MeNBtoSgNBContainer>(7); }
64994                 bool is_unknown() const { return type == 8; }
64995                 void clear()
64996                 {
64997                         switch(type)
64998                         {
64999                         case 1: var.destroy<UE_X2AP_ID>(); break;
65000                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65001                         case 3: var.destroy<Cause>(); break;
65002                         case 4: var.destroy<E_RABs_ToBeReleased_SgNBRelReqList>(); break;
65003                         case 5: var.destroy<UE_ContextKeptIndicator>(); break;
65004                         case 6: var.destroy<UE_X2AP_ID_Extension>(); break;
65005                         case 7: var.destroy<MeNBtoSgNBContainer>(); break;
65006                         }
65007                         type = 0; ref_nested().clear();
65008                 }
65009                 template<typename V> static inline void enumerate(V& v)
65010                 {
65011                         v.template operator()<UE_X2AP_ID>(1);
65012                         v.template operator()<SgNB_UE_X2AP_ID>(2);
65013                         v.template operator()<Cause>(3);
65014                         v.template operator()<E_RABs_ToBeReleased_SgNBRelReqList>(4);
65015                         v.template operator()<UE_ContextKeptIndicator>(5);
65016                         v.template operator()<UE_X2AP_ID_Extension>(6);
65017                         v.template operator()<MeNBtoSgNBContainer>(7);
65018
65019                 }
65020                 protected:
65021                 template<typename V> bool decode(size_t index, V& v)
65022                 {
65023                         clear();
65024                         switch(index)
65025                         {
65026                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65027                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65028                         case 3: v(select_id_Cause()); return true;
65029                         case 4: v(select_id_E_RABs_ToBeReleased_SgNBRelReqList()); return true;
65030                         case 5: v(select_id_UE_ContextKeptIndicator()); return true;
65031                         case 6: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65032                         case 7: v(select_id_MeNBtoSgNBContainer()); return true;
65033                         case 8: if(type != 8) {clear(); asn::base::set();} type = 8; return true;
65034                         }
65035                         return false;
65036
65037                 }
65038                 template<typename V> bool encode(size_t index, V& v) const
65039                 {
65040                         if(index != type) return false;
65041                         switch(type)
65042                         {
65043                         case 1: v(var.as<UE_X2AP_ID>()); return true;
65044                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65045                         case 3: v(var.as<Cause>()); return true;
65046                         case 4: v(var.as<E_RABs_ToBeReleased_SgNBRelReqList>()); return true;
65047                         case 5: v(var.as<UE_ContextKeptIndicator>()); return true;
65048                         case 6: v(var.as<UE_X2AP_ID_Extension>()); return true;
65049                         case 7: v(var.as<MeNBtoSgNBContainer>()); return true;
65050                         }
65051                         return false;
65052
65053                 }
65054                 private:
65055                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65056                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65057                 union union_type
65058                 {
65059                         char dummy1[sizeof(Cause)];
65060                         char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelReqList)];
65061                         char dummy3[sizeof(MeNBtoSgNBContainer)];
65062                         char dummy4[sizeof(SgNB_UE_X2AP_ID)];
65063                         char dummy5[sizeof(UE_ContextKeptIndicator)];
65064                         char dummy6[sizeof(UE_X2AP_ID)];
65065                         char dummy7[sizeof(UE_X2AP_ID_Extension)];
65066
65067                 };
65068                 asn::variant<sizeof(union_type)> var;
65069                 size_t type {0};
65070
65071         };
65072         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65073         {
65074                 size_t get_index() const {return type;}
65075                 bool is_unknown() const { return type == 8; }
65076                 void clear() {type = 0;}
65077                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65078                 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=2;}
65079                 void select_id_Cause() { set(mandatory); type=3;}
65080                 void select_id_E_RABs_ToBeReleased_SgNBRelReqList() { set(optional); type=4;}
65081                 void select_id_UE_ContextKeptIndicator() { set(optional); type=5;}
65082                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=6;}
65083                 void select_id_MeNBtoSgNBContainer() { set(optional); type=7;}
65084                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65085                 template<typename V>  bool decode(V& v)
65086                 {
65087                         clear();
65088                         if(!v(ref_nested())) return false;
65089                         if(equal(mandatory)) { type = 1; return true; }
65090                         else if(equal(optional)) { type = 2; return true; }
65091                         else if(equal(mandatory)) { type = 3; return true; }
65092                         else if(equal(optional)) { type = 4; return true; }
65093                         else if(equal(optional)) { type = 5; return true; }
65094                         else if(equal(optional)) { type = 6; return true; }
65095                         else if(equal(optional)) { type = 7; return true; }
65096                         else { type = 8; return true;}
65097                         return false;
65098
65099                 }
65100                 template<typename V> bool encode(V& v) const
65101                 {
65102                         return v(ref_nested());
65103
65104                 }
65105                 protected:
65106                 template<typename V>  bool decode(size_t index, V& v)
65107                 {
65108                         clear();
65109                         switch(index)
65110                         {
65111                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65112                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
65113                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
65114                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65115                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65116                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
65117                         case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
65118                         case 8: type = 8; return v(ref_nested());
65119                         ref_nested().clear();
65120                         }
65121                         return false;
65122
65123                 }
65124                 template<typename V> bool encode(size_t index, V& v) const
65125                 {
65126                         if(index != type) {return false;} return v(ref_nested());
65127
65128                 }
65129                 private:
65130                 size_t type {0};
65131
65132         };
65133
65134 };
65135 /*
65136 SgNBReleaseRequest ::= SEQUENCE {
65137         protocolIEs             ProtocolIE-Container            {{SgNBReleaseRequest-IEs}},
65138         ...
65139 }
65140 */
65141
65142 struct SgNBReleaseRequest : asn::sequence<1, 0, true, 0>
65143 {
65144         static constexpr const char* name() {return "SgNBReleaseRequest";}
65145         using parent_t = asn::sequence<1, 0, true, 0>;
65146         struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequest_IEs>
65147         {
65148                 static constexpr const char* name() {return "protocolIEs_t";}
65149                 using parent_t = ProtocolIE_Container<SgNBReleaseRequest_IEs>;
65150
65151         };
65152         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65153         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65154         template<typename V> void decode(V& v)
65155         {
65156                 v(protocolIEs);
65157
65158         };
65159         template<typename V> void encode(V& v) const
65160         {
65161                 v(protocolIEs);
65162
65163         };
65164         void clear()
65165         {
65166                 protocolIEs.clear();
65167
65168         };
65169         private:
65170         protocolIEs_t   protocolIEs;
65171
65172 };
65173 /*
65174 SgNBReleaseRequestAcknowledge-IEs X2AP-PROTOCOL-IES ::= {
65175         { ID id-MeNB-UE-X2AP-ID                                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
65176         { ID id-SgNB-UE-X2AP-ID                                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                            PRESENCE mandatory}|
65177         { ID id-CriticalityDiagnostics                                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional }|
65178         { ID id-MeNB-UE-X2AP-ID-Extension                                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional }|
65179         { ID id-E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList  CRITICALITY ignore      TYPE E-RABs-Admitted-ToBeReleased-SgNBRelReqAckList     PRESENCE optional },
65180         ...
65181 }
65182 */
65183
65184 struct SgNBReleaseRequestAcknowledge_IEs
65185 {
65186         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65187         {
65188                 size_t get_index() const {return type;}
65189                 bool is_unknown() const { return type == 6; }
65190                 void clear() {type = 0;}
65191                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65192                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65193                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
65194                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
65195                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList); type=5;}
65196                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65197                 template<typename V>  bool decode(V& v)
65198                 {
65199                         clear();
65200                         if(!v(ref_nested())) return false;
65201                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65202                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65203                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
65204                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
65205                         else if(equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)) { type = 5; return true; }
65206                         else { type = 6; return true;}
65207                         return false;
65208
65209                 }
65210                 template<typename V> bool encode(V& v) const
65211                 {
65212                         return v(ref_nested());
65213
65214                 }
65215                 protected:
65216                 template<typename V>  bool decode(size_t index, V& v)
65217                 {
65218                         clear();
65219                         switch(index)
65220                         {
65221                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65222                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65223                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
65224                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65225                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList);} return false;
65226                         case 6: type = 6; return v(ref_nested());
65227                         ref_nested().clear();
65228                         }
65229                         return false;
65230
65231                 }
65232                 template<typename V> bool encode(size_t index, V& v) const
65233                 {
65234                         if(index != type) {return false;} return v(ref_nested());
65235
65236                 }
65237                 private:
65238                 size_t type {0};
65239
65240         };
65241         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65242         {
65243                 size_t get_index() const {return type;}
65244                 bool is_unknown() const { return type == 6; }
65245                 void clear() {type = 0;}
65246                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
65247                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
65248                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
65249                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
65250                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(ignore); type=5;}
65251                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65252                 template<typename V>  bool decode(V& v)
65253                 {
65254                         clear();
65255                         if(!v(ref_nested())) return false;
65256                         if(equal(ignore)) { type = 1; return true; }
65257                         else if(equal(ignore)) { type = 2; return true; }
65258                         else if(equal(ignore)) { type = 3; return true; }
65259                         else if(equal(reject)) { type = 4; return true; }
65260                         else if(equal(ignore)) { type = 5; return true; }
65261                         else { type = 6; return true;}
65262                         return false;
65263
65264                 }
65265                 template<typename V> bool encode(V& v) const
65266                 {
65267                         return v(ref_nested());
65268
65269                 }
65270                 protected:
65271                 template<typename V>  bool decode(size_t index, V& v)
65272                 {
65273                         clear();
65274                         switch(index)
65275                         {
65276                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
65277                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
65278                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65279                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
65280                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
65281                         case 6: type = 6; return v(ref_nested());
65282                         ref_nested().clear();
65283                         }
65284                         return false;
65285
65286                 }
65287                 template<typename V> bool encode(size_t index, V& v) const
65288                 {
65289                         if(index != type) {return false;} return v(ref_nested());
65290
65291                 }
65292                 private:
65293                 size_t type {0};
65294
65295         };
65296         struct Value_t : asn::typefield<true>
65297         {
65298                 ~Value_t()      {clear();}
65299                 size_t get_index() const {return type;}
65300                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65301                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65302                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65303                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65304                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
65305                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
65306                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
65307                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
65308                 E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList& select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { return set<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
65309                 E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList const* get_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() const { return get<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5); }
65310                 bool is_unknown() const { return type == 6; }
65311                 void clear()
65312                 {
65313                         switch(type)
65314                         {
65315                         case 1: var.destroy<UE_X2AP_ID>(); break;
65316                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65317                         case 3: var.destroy<CriticalityDiagnostics>(); break;
65318                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
65319                         case 5: var.destroy<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(); break;
65320                         }
65321                         type = 0; ref_nested().clear();
65322                 }
65323                 template<typename V> static inline void enumerate(V& v)
65324                 {
65325                         v.template operator()<UE_X2AP_ID>(1);
65326                         v.template operator()<SgNB_UE_X2AP_ID>(2);
65327                         v.template operator()<CriticalityDiagnostics>(3);
65328                         v.template operator()<UE_X2AP_ID_Extension>(4);
65329                         v.template operator()<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>(5);
65330
65331                 }
65332                 protected:
65333                 template<typename V> bool decode(size_t index, V& v)
65334                 {
65335                         clear();
65336                         switch(index)
65337                         {
65338                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65339                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65340                         case 3: v(select_id_CriticalityDiagnostics()); return true;
65341                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65342                         case 5: v(select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList()); return true;
65343                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65344                         }
65345                         return false;
65346
65347                 }
65348                 template<typename V> bool encode(size_t index, V& v) const
65349                 {
65350                         if(index != type) return false;
65351                         switch(type)
65352                         {
65353                         case 1: v(var.as<UE_X2AP_ID>()); return true;
65354                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65355                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
65356                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
65357                         case 5: v(var.as<E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList>()); return true;
65358                         }
65359                         return false;
65360
65361                 }
65362                 private:
65363                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65364                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65365                 union union_type
65366                 {
65367                         char dummy1[sizeof(CriticalityDiagnostics)];
65368                         char dummy2[sizeof(E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList)];
65369                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65370                         char dummy4[sizeof(UE_X2AP_ID)];
65371                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
65372
65373                 };
65374                 asn::variant<sizeof(union_type)> var;
65375                 size_t type {0};
65376
65377         };
65378         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65379         {
65380                 size_t get_index() const {return type;}
65381                 bool is_unknown() const { return type == 6; }
65382                 void clear() {type = 0;}
65383                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65384                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65385                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
65386                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
65387                 void select_id_E_RABs_Admitted_ToBeReleased_SgNBRelReqAckList() { set(optional); type=5;}
65388                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65389                 template<typename V>  bool decode(V& v)
65390                 {
65391                         clear();
65392                         if(!v(ref_nested())) return false;
65393                         if(equal(mandatory)) { type = 1; return true; }
65394                         else if(equal(mandatory)) { type = 2; return true; }
65395                         else if(equal(optional)) { type = 3; return true; }
65396                         else if(equal(optional)) { type = 4; return true; }
65397                         else if(equal(optional)) { type = 5; return true; }
65398                         else { type = 6; return true;}
65399                         return false;
65400
65401                 }
65402                 template<typename V> bool encode(V& v) const
65403                 {
65404                         return v(ref_nested());
65405
65406                 }
65407                 protected:
65408                 template<typename V>  bool decode(size_t index, V& v)
65409                 {
65410                         clear();
65411                         switch(index)
65412                         {
65413                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65414                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
65415                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
65416                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65417                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65418                         case 6: type = 6; return v(ref_nested());
65419                         ref_nested().clear();
65420                         }
65421                         return false;
65422
65423                 }
65424                 template<typename V> bool encode(size_t index, V& v) const
65425                 {
65426                         if(index != type) {return false;} return v(ref_nested());
65427
65428                 }
65429                 private:
65430                 size_t type {0};
65431
65432         };
65433
65434 };
65435 /*
65436 SgNBReleaseRequestAcknowledge ::= SEQUENCE {
65437         protocolIEs             ProtocolIE-Container            {{SgNBReleaseRequestAcknowledge-IEs}},
65438         ...
65439 }
65440 */
65441
65442 struct SgNBReleaseRequestAcknowledge : asn::sequence<1, 0, true, 0>
65443 {
65444         static constexpr const char* name() {return "SgNBReleaseRequestAcknowledge";}
65445         using parent_t = asn::sequence<1, 0, true, 0>;
65446         struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>
65447         {
65448                 static constexpr const char* name() {return "protocolIEs_t";}
65449                 using parent_t = ProtocolIE_Container<SgNBReleaseRequestAcknowledge_IEs>;
65450
65451         };
65452         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65453         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65454         template<typename V> void decode(V& v)
65455         {
65456                 v(protocolIEs);
65457
65458         };
65459         template<typename V> void encode(V& v) const
65460         {
65461                 v(protocolIEs);
65462
65463         };
65464         void clear()
65465         {
65466                 protocolIEs.clear();
65467
65468         };
65469         private:
65470         protocolIEs_t   protocolIEs;
65471
65472 };
65473 /*
65474 SgNBReleaseRequestReject-IEs X2AP-PROTOCOL-IES ::= {
65475         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE UE-X2AP-ID                                                                         PRESENCE mandatory}|
65476         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                                    PRESENCE mandatory}|
65477         { ID id-Cause                                                                   CRITICALITY ignore      TYPE Cause                                                                                      PRESENCE mandatory}|
65478         { ID id-CriticalityDiagnostics                                  CRITICALITY ignore      TYPE CriticalityDiagnostics                                             PRESENCE optional}|
65479         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional},
65480         ...
65481 }
65482 */
65483
65484 struct SgNBReleaseRequestReject_IEs
65485 {
65486         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65487         {
65488                 size_t get_index() const {return type;}
65489                 bool is_unknown() const { return type == 6; }
65490                 void clear() {type = 0;}
65491                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65492                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65493                 void select_id_Cause() { set(id_Cause); type=3;}
65494                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
65495                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=5;}
65496                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65497                 template<typename V>  bool decode(V& v)
65498                 {
65499                         clear();
65500                         if(!v(ref_nested())) return false;
65501                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65502                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65503                         else if(equal(id_Cause)) { type = 3; return true; }
65504                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
65505                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 5; return true; }
65506                         else { type = 6; return true;}
65507                         return false;
65508
65509                 }
65510                 template<typename V> bool encode(V& v) const
65511                 {
65512                         return v(ref_nested());
65513
65514                 }
65515                 protected:
65516                 template<typename V>  bool decode(size_t index, V& v)
65517                 {
65518                         clear();
65519                         switch(index)
65520                         {
65521                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65522                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65523                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
65524                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
65525                         case 5: type = 5; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65526                         case 6: type = 6; return v(ref_nested());
65527                         ref_nested().clear();
65528                         }
65529                         return false;
65530
65531                 }
65532                 template<typename V> bool encode(size_t index, V& v) const
65533                 {
65534                         if(index != type) {return false;} return v(ref_nested());
65535
65536                 }
65537                 private:
65538                 size_t type {0};
65539
65540         };
65541         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65542         {
65543                 size_t get_index() const {return type;}
65544                 bool is_unknown() const { return type == 6; }
65545                 void clear() {type = 0;}
65546                 void select_id_MeNB_UE_X2AP_ID() { set(ignore); type=1;}
65547                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=2;}
65548                 void select_id_Cause() { set(ignore); type=3;}
65549                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
65550                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=5;}
65551                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65552                 template<typename V>  bool decode(V& v)
65553                 {
65554                         clear();
65555                         if(!v(ref_nested())) return false;
65556                         if(equal(ignore)) { type = 1; return true; }
65557                         else if(equal(ignore)) { type = 2; return true; }
65558                         else if(equal(ignore)) { type = 3; return true; }
65559                         else if(equal(ignore)) { type = 4; return true; }
65560                         else if(equal(reject)) { type = 5; return true; }
65561                         else { type = 6; return true;}
65562                         return false;
65563
65564                 }
65565                 template<typename V> bool encode(V& v) const
65566                 {
65567                         return v(ref_nested());
65568
65569                 }
65570                 protected:
65571                 template<typename V>  bool decode(size_t index, V& v)
65572                 {
65573                         clear();
65574                         switch(index)
65575                         {
65576                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
65577                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
65578                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65579                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
65580                         case 5: type = 5; if(v(ref_nested())) { return equal(reject);} return false;
65581                         case 6: type = 6; return v(ref_nested());
65582                         ref_nested().clear();
65583                         }
65584                         return false;
65585
65586                 }
65587                 template<typename V> bool encode(size_t index, V& v) const
65588                 {
65589                         if(index != type) {return false;} return v(ref_nested());
65590
65591                 }
65592                 private:
65593                 size_t type {0};
65594
65595         };
65596         struct Value_t : asn::typefield<true>
65597         {
65598                 ~Value_t()      {clear();}
65599                 size_t get_index() const {return type;}
65600                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65601                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65602                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65603                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65604                 Cause& select_id_Cause() { return set<Cause>(3); }
65605                 Cause const* get_id_Cause() const { return get<Cause>(3); }
65606                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
65607                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
65608                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(5); }
65609                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(5); }
65610                 bool is_unknown() const { return type == 6; }
65611                 void clear()
65612                 {
65613                         switch(type)
65614                         {
65615                         case 1: var.destroy<UE_X2AP_ID>(); break;
65616                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65617                         case 3: var.destroy<Cause>(); break;
65618                         case 4: var.destroy<CriticalityDiagnostics>(); break;
65619                         case 5: var.destroy<UE_X2AP_ID_Extension>(); break;
65620                         }
65621                         type = 0; ref_nested().clear();
65622                 }
65623                 template<typename V> static inline void enumerate(V& v)
65624                 {
65625                         v.template operator()<UE_X2AP_ID>(1);
65626                         v.template operator()<SgNB_UE_X2AP_ID>(2);
65627                         v.template operator()<Cause>(3);
65628                         v.template operator()<CriticalityDiagnostics>(4);
65629                         v.template operator()<UE_X2AP_ID_Extension>(5);
65630
65631                 }
65632                 protected:
65633                 template<typename V> bool decode(size_t index, V& v)
65634                 {
65635                         clear();
65636                         switch(index)
65637                         {
65638                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65639                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65640                         case 3: v(select_id_Cause()); return true;
65641                         case 4: v(select_id_CriticalityDiagnostics()); return true;
65642                         case 5: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65643                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65644                         }
65645                         return false;
65646
65647                 }
65648                 template<typename V> bool encode(size_t index, V& v) const
65649                 {
65650                         if(index != type) return false;
65651                         switch(type)
65652                         {
65653                         case 1: v(var.as<UE_X2AP_ID>()); return true;
65654                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65655                         case 3: v(var.as<Cause>()); return true;
65656                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
65657                         case 5: v(var.as<UE_X2AP_ID_Extension>()); return true;
65658                         }
65659                         return false;
65660
65661                 }
65662                 private:
65663                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65664                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65665                 union union_type
65666                 {
65667                         char dummy1[sizeof(Cause)];
65668                         char dummy2[sizeof(CriticalityDiagnostics)];
65669                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65670                         char dummy4[sizeof(UE_X2AP_ID)];
65671                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
65672
65673                 };
65674                 asn::variant<sizeof(union_type)> var;
65675                 size_t type {0};
65676
65677         };
65678         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65679         {
65680                 size_t get_index() const {return type;}
65681                 bool is_unknown() const { return type == 6; }
65682                 void clear() {type = 0;}
65683                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65684                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65685                 void select_id_Cause() { set(mandatory); type=3;}
65686                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
65687                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=5;}
65688                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65689                 template<typename V>  bool decode(V& v)
65690                 {
65691                         clear();
65692                         if(!v(ref_nested())) return false;
65693                         if(equal(mandatory)) { type = 1; return true; }
65694                         else if(equal(mandatory)) { type = 2; return true; }
65695                         else if(equal(mandatory)) { type = 3; return true; }
65696                         else if(equal(optional)) { type = 4; return true; }
65697                         else if(equal(optional)) { type = 5; return true; }
65698                         else { type = 6; return true;}
65699                         return false;
65700
65701                 }
65702                 template<typename V> bool encode(V& v) const
65703                 {
65704                         return v(ref_nested());
65705
65706                 }
65707                 protected:
65708                 template<typename V>  bool decode(size_t index, V& v)
65709                 {
65710                         clear();
65711                         switch(index)
65712                         {
65713                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
65714                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
65715                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
65716                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
65717                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
65718                         case 6: type = 6; return v(ref_nested());
65719                         ref_nested().clear();
65720                         }
65721                         return false;
65722
65723                 }
65724                 template<typename V> bool encode(size_t index, V& v) const
65725                 {
65726                         if(index != type) {return false;} return v(ref_nested());
65727
65728                 }
65729                 private:
65730                 size_t type {0};
65731
65732         };
65733
65734 };
65735 /*
65736 SgNBReleaseRequestReject ::= SEQUENCE {
65737         protocolIEs             ProtocolIE-Container            {{SgNBReleaseRequestReject-IEs}},
65738         ...
65739 }
65740 */
65741
65742 struct SgNBReleaseRequestReject : asn::sequence<1, 0, true, 0>
65743 {
65744         static constexpr const char* name() {return "SgNBReleaseRequestReject";}
65745         using parent_t = asn::sequence<1, 0, true, 0>;
65746         struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequestReject_IEs>
65747         {
65748                 static constexpr const char* name() {return "protocolIEs_t";}
65749                 using parent_t = ProtocolIE_Container<SgNBReleaseRequestReject_IEs>;
65750
65751         };
65752         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
65753         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
65754         template<typename V> void decode(V& v)
65755         {
65756                 v(protocolIEs);
65757
65758         };
65759         template<typename V> void encode(V& v) const
65760         {
65761                 v(protocolIEs);
65762
65763         };
65764         void clear()
65765         {
65766                 protocolIEs.clear();
65767
65768         };
65769         private:
65770         protocolIEs_t   protocolIEs;
65771
65772 };
65773 /*
65774 SgNBReleaseRequired-IEs X2AP-PROTOCOL-IES ::= {
65775         { ID id-MeNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE UE-X2AP-ID                                                                                 PRESENCE mandatory}|
65776         { ID id-SgNB-UE-X2AP-ID                                                 CRITICALITY reject      TYPE SgNB-UE-X2AP-ID                                                                            PRESENCE mandatory}|
65777         { ID id-Cause                                                                   CRITICALITY ignore      TYPE Cause                                                                                              PRESENCE mandatory}|
65778         { ID id-MeNB-UE-X2AP-ID-Extension                               CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                                       PRESENCE optional }|
65779         { ID id-E-RABs-ToBeReleased-SgNBRelReqdList             CRITICALITY ignore      TYPE E-RABs-ToBeReleased-SgNBRelReqdList                PRESENCE optional },
65780         ...
65781 }
65782 */
65783
65784 struct SgNBReleaseRequired_IEs
65785 {
65786         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
65787         {
65788                 size_t get_index() const {return type;}
65789                 bool is_unknown() const { return type == 6; }
65790                 void clear() {type = 0;}
65791                 void select_id_MeNB_UE_X2AP_ID() { set(id_MeNB_UE_X2AP_ID); type=1;}
65792                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=2;}
65793                 void select_id_Cause() { set(id_Cause); type=3;}
65794                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(id_MeNB_UE_X2AP_ID_Extension); type=4;}
65795                 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(id_E_RABs_ToBeReleased_SgNBRelReqdList); type=5;}
65796                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
65797                 template<typename V>  bool decode(V& v)
65798                 {
65799                         clear();
65800                         if(!v(ref_nested())) return false;
65801                         if(equal(id_MeNB_UE_X2AP_ID)) { type = 1; return true; }
65802                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 2; return true; }
65803                         else if(equal(id_Cause)) { type = 3; return true; }
65804                         else if(equal(id_MeNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
65805                         else if(equal(id_E_RABs_ToBeReleased_SgNBRelReqdList)) { type = 5; return true; }
65806                         else { type = 6; return true;}
65807                         return false;
65808
65809                 }
65810                 template<typename V> bool encode(V& v) const
65811                 {
65812                         return v(ref_nested());
65813
65814                 }
65815                 protected:
65816                 template<typename V>  bool decode(size_t index, V& v)
65817                 {
65818                         clear();
65819                         switch(index)
65820                         {
65821                         case 1: type = 1; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID);} return false;
65822                         case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
65823                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Cause);} return false;
65824                         case 4: type = 4; if(v(ref_nested())) { return equal(id_MeNB_UE_X2AP_ID_Extension);} return false;
65825                         case 5: type = 5; if(v(ref_nested())) { return equal(id_E_RABs_ToBeReleased_SgNBRelReqdList);} return false;
65826                         case 6: type = 6; return v(ref_nested());
65827                         ref_nested().clear();
65828                         }
65829                         return false;
65830
65831                 }
65832                 template<typename V> bool encode(size_t index, V& v) const
65833                 {
65834                         if(index != type) {return false;} return v(ref_nested());
65835
65836                 }
65837                 private:
65838                 size_t type {0};
65839
65840         };
65841         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
65842         {
65843                 size_t get_index() const {return type;}
65844                 bool is_unknown() const { return type == 6; }
65845                 void clear() {type = 0;}
65846                 void select_id_MeNB_UE_X2AP_ID() { set(reject); type=1;}
65847                 void select_id_SgNB_UE_X2AP_ID() { set(reject); type=2;}
65848                 void select_id_Cause() { set(ignore); type=3;}
65849                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
65850                 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(ignore); type=5;}
65851                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
65852                 template<typename V>  bool decode(V& v)
65853                 {
65854                         clear();
65855                         if(!v(ref_nested())) return false;
65856                         if(equal(reject)) { type = 1; return true; }
65857                         else if(equal(reject)) { type = 2; return true; }
65858                         else if(equal(ignore)) { type = 3; return true; }
65859                         else if(equal(reject)) { type = 4; return true; }
65860                         else if(equal(ignore)) { type = 5; return true; }
65861                         else { type = 6; return true;}
65862                         return false;
65863
65864                 }
65865                 template<typename V> bool encode(V& v) const
65866                 {
65867                         return v(ref_nested());
65868
65869                 }
65870                 protected:
65871                 template<typename V>  bool decode(size_t index, V& v)
65872                 {
65873                         clear();
65874                         switch(index)
65875                         {
65876                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
65877                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
65878                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
65879                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
65880                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
65881                         case 6: type = 6; return v(ref_nested());
65882                         ref_nested().clear();
65883                         }
65884                         return false;
65885
65886                 }
65887                 template<typename V> bool encode(size_t index, V& v) const
65888                 {
65889                         if(index != type) {return false;} return v(ref_nested());
65890
65891                 }
65892                 private:
65893                 size_t type {0};
65894
65895         };
65896         struct Value_t : asn::typefield<true>
65897         {
65898                 ~Value_t()      {clear();}
65899                 size_t get_index() const {return type;}
65900                 UE_X2AP_ID& select_id_MeNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
65901                 UE_X2AP_ID const* get_id_MeNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
65902                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(2); }
65903                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(2); }
65904                 Cause& select_id_Cause() { return set<Cause>(3); }
65905                 Cause const* get_id_Cause() const { return get<Cause>(3); }
65906                 UE_X2AP_ID_Extension& select_id_MeNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
65907                 UE_X2AP_ID_Extension const* get_id_MeNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
65908                 E_RABs_ToBeReleased_SgNBRelReqdList& select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { return set<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
65909                 E_RABs_ToBeReleased_SgNBRelReqdList const* get_id_E_RABs_ToBeReleased_SgNBRelReqdList() const { return get<E_RABs_ToBeReleased_SgNBRelReqdList>(5); }
65910                 bool is_unknown() const { return type == 6; }
65911                 void clear()
65912                 {
65913                         switch(type)
65914                         {
65915                         case 1: var.destroy<UE_X2AP_ID>(); break;
65916                         case 2: var.destroy<SgNB_UE_X2AP_ID>(); break;
65917                         case 3: var.destroy<Cause>(); break;
65918                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
65919                         case 5: var.destroy<E_RABs_ToBeReleased_SgNBRelReqdList>(); break;
65920                         }
65921                         type = 0; ref_nested().clear();
65922                 }
65923                 template<typename V> static inline void enumerate(V& v)
65924                 {
65925                         v.template operator()<UE_X2AP_ID>(1);
65926                         v.template operator()<SgNB_UE_X2AP_ID>(2);
65927                         v.template operator()<Cause>(3);
65928                         v.template operator()<UE_X2AP_ID_Extension>(4);
65929                         v.template operator()<E_RABs_ToBeReleased_SgNBRelReqdList>(5);
65930
65931                 }
65932                 protected:
65933                 template<typename V> bool decode(size_t index, V& v)
65934                 {
65935                         clear();
65936                         switch(index)
65937                         {
65938                         case 1: v(select_id_MeNB_UE_X2AP_ID()); return true;
65939                         case 2: v(select_id_SgNB_UE_X2AP_ID()); return true;
65940                         case 3: v(select_id_Cause()); return true;
65941                         case 4: v(select_id_MeNB_UE_X2AP_ID_Extension()); return true;
65942                         case 5: v(select_id_E_RABs_ToBeReleased_SgNBRelReqdList()); return true;
65943                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
65944                         }
65945                         return false;
65946
65947                 }
65948                 template<typename V> bool encode(size_t index, V& v) const
65949                 {
65950                         if(index != type) return false;
65951                         switch(type)
65952                         {
65953                         case 1: v(var.as<UE_X2AP_ID>()); return true;
65954                         case 2: v(var.as<SgNB_UE_X2AP_ID>()); return true;
65955                         case 3: v(var.as<Cause>()); return true;
65956                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
65957                         case 5: v(var.as<E_RABs_ToBeReleased_SgNBRelReqdList>()); return true;
65958                         }
65959                         return false;
65960
65961                 }
65962                 private:
65963                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
65964                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
65965                 union union_type
65966                 {
65967                         char dummy1[sizeof(Cause)];
65968                         char dummy2[sizeof(E_RABs_ToBeReleased_SgNBRelReqdList)];
65969                         char dummy3[sizeof(SgNB_UE_X2AP_ID)];
65970                         char dummy4[sizeof(UE_X2AP_ID)];
65971                         char dummy5[sizeof(UE_X2AP_ID_Extension)];
65972
65973                 };
65974                 asn::variant<sizeof(union_type)> var;
65975                 size_t type {0};
65976
65977         };
65978         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
65979         {
65980                 size_t get_index() const {return type;}
65981                 bool is_unknown() const { return type == 6; }
65982                 void clear() {type = 0;}
65983                 void select_id_MeNB_UE_X2AP_ID() { set(mandatory); type=1;}
65984                 void select_id_SgNB_UE_X2AP_ID() { set(mandatory); type=2;}
65985                 void select_id_Cause() { set(mandatory); type=3;}
65986                 void select_id_MeNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
65987                 void select_id_E_RABs_ToBeReleased_SgNBRelReqdList() { set(optional); type=5;}
65988                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
65989                 template<typename V>  bool decode(V& v)
65990                 {
65991                         clear();
65992                         if(!v(ref_nested())) return false;
65993                         if(equal(mandatory)) { type = 1; return true; }
65994                         else if(equal(mandatory)) { type = 2; return true; }
65995                         else if(equal(mandatory)) { type = 3; return true; }
65996                         else if(equal(optional)) { type = 4; return true; }
65997                         else if(equal(optional)) { type = 5; return true; }
65998                         else { type = 6; return true;}
65999                         return false;
66000
66001                 }
66002                 template<typename V> bool encode(V& v) const
66003                 {
66004                         return v(ref_nested());
66005
66006                 }
66007                 protected:
66008                 template<typename V>  bool decode(size_t index, V& v)
66009                 {
66010                         clear();
66011                         switch(index)
66012                         {
66013                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66014                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
66015                         case 3: type = 3; if(v(ref_nested())) { return equal(mandatory);} return false;
66016                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
66017                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
66018                         case 6: type = 6; return v(ref_nested());
66019                         ref_nested().clear();
66020                         }
66021                         return false;
66022
66023                 }
66024                 template<typename V> bool encode(size_t index, V& v) const
66025                 {
66026                         if(index != type) {return false;} return v(ref_nested());
66027
66028                 }
66029                 private:
66030                 size_t type {0};
66031
66032         };
66033
66034 };
66035 /*
66036 SgNBReleaseRequired ::= SEQUENCE {
66037         protocolIEs             ProtocolIE-Container    {{SgNBReleaseRequired-IEs}},
66038         ...
66039 }
66040 */
66041
66042 struct SgNBReleaseRequired : asn::sequence<1, 0, true, 0>
66043 {
66044         static constexpr const char* name() {return "SgNBReleaseRequired";}
66045         using parent_t = asn::sequence<1, 0, true, 0>;
66046         struct protocolIEs_t : ProtocolIE_Container<SgNBReleaseRequired_IEs>
66047         {
66048                 static constexpr const char* name() {return "protocolIEs_t";}
66049                 using parent_t = ProtocolIE_Container<SgNBReleaseRequired_IEs>;
66050
66051         };
66052         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66053         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66054         template<typename V> void decode(V& v)
66055         {
66056                 v(protocolIEs);
66057
66058         };
66059         template<typename V> void encode(V& v) const
66060         {
66061                 v(protocolIEs);
66062
66063         };
66064         void clear()
66065         {
66066                 protocolIEs.clear();
66067
66068         };
66069         private:
66070         protocolIEs_t   protocolIEs;
66071
66072 };
66073 /*
66074 UEContextRelease-IEs X2AP-PROTOCOL-IES ::= {
66075         { ID id-Old-eNB-UE-X2AP-ID                                      CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
66076         { ID id-New-eNB-UE-X2AP-ID                                      CRITICALITY reject      TYPE UE-X2AP-ID                                                                 PRESENCE mandatory}|
66077         { ID id-Old-eNB-UE-X2AP-ID-Extension            CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
66078         { ID id-New-eNB-UE-X2AP-ID-Extension            CRITICALITY reject      TYPE UE-X2AP-ID-Extension                                               PRESENCE optional}|
66079         { ID id-SIPTO-BearerDeactivationIndication      CRITICALITY ignore      TYPE SIPTOBearerDeactivationIndication          PRESENCE optional}|
66080         { ID id-SgNB-UE-X2AP-ID                                         CRITICALITY ignore      TYPE SgNB-UE-X2AP-ID                                                    PRESENCE optional},
66081         ...
66082 }
66083 */
66084
66085 struct UEContextRelease_IEs
66086 {
66087         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66088         {
66089                 size_t get_index() const {return type;}
66090                 bool is_unknown() const { return type == 7; }
66091                 void clear() {type = 0;}
66092                 void select_id_Old_eNB_UE_X2AP_ID() { set(id_Old_eNB_UE_X2AP_ID); type=1;}
66093                 void select_id_New_eNB_UE_X2AP_ID() { set(id_New_eNB_UE_X2AP_ID); type=2;}
66094                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(id_Old_eNB_UE_X2AP_ID_Extension); type=3;}
66095                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(id_New_eNB_UE_X2AP_ID_Extension); type=4;}
66096                 void select_id_SIPTO_BearerDeactivationIndication() { set(id_SIPTO_BearerDeactivationIndication); type=5;}
66097                 void select_id_SgNB_UE_X2AP_ID() { set(id_SgNB_UE_X2AP_ID); type=6;}
66098                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66099                 template<typename V>  bool decode(V& v)
66100                 {
66101                         clear();
66102                         if(!v(ref_nested())) return false;
66103                         if(equal(id_Old_eNB_UE_X2AP_ID)) { type = 1; return true; }
66104                         else if(equal(id_New_eNB_UE_X2AP_ID)) { type = 2; return true; }
66105                         else if(equal(id_Old_eNB_UE_X2AP_ID_Extension)) { type = 3; return true; }
66106                         else if(equal(id_New_eNB_UE_X2AP_ID_Extension)) { type = 4; return true; }
66107                         else if(equal(id_SIPTO_BearerDeactivationIndication)) { type = 5; return true; }
66108                         else if(equal(id_SgNB_UE_X2AP_ID)) { type = 6; return true; }
66109                         else { type = 7; return true;}
66110                         return false;
66111
66112                 }
66113                 template<typename V> bool encode(V& v) const
66114                 {
66115                         return v(ref_nested());
66116
66117                 }
66118                 protected:
66119                 template<typename V>  bool decode(size_t index, V& v)
66120                 {
66121                         clear();
66122                         switch(index)
66123                         {
66124                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID);} return false;
66125                         case 2: type = 2; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID);} return false;
66126                         case 3: type = 3; if(v(ref_nested())) { return equal(id_Old_eNB_UE_X2AP_ID_Extension);} return false;
66127                         case 4: type = 4; if(v(ref_nested())) { return equal(id_New_eNB_UE_X2AP_ID_Extension);} return false;
66128                         case 5: type = 5; if(v(ref_nested())) { return equal(id_SIPTO_BearerDeactivationIndication);} return false;
66129                         case 6: type = 6; if(v(ref_nested())) { return equal(id_SgNB_UE_X2AP_ID);} return false;
66130                         case 7: type = 7; return v(ref_nested());
66131                         ref_nested().clear();
66132                         }
66133                         return false;
66134
66135                 }
66136                 template<typename V> bool encode(size_t index, V& v) const
66137                 {
66138                         if(index != type) {return false;} return v(ref_nested());
66139
66140                 }
66141                 private:
66142                 size_t type {0};
66143
66144         };
66145         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66146         {
66147                 size_t get_index() const {return type;}
66148                 bool is_unknown() const { return type == 7; }
66149                 void clear() {type = 0;}
66150                 void select_id_Old_eNB_UE_X2AP_ID() { set(reject); type=1;}
66151                 void select_id_New_eNB_UE_X2AP_ID() { set(reject); type=2;}
66152                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(reject); type=3;}
66153                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(reject); type=4;}
66154                 void select_id_SIPTO_BearerDeactivationIndication() { set(ignore); type=5;}
66155                 void select_id_SgNB_UE_X2AP_ID() { set(ignore); type=6;}
66156                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66157                 template<typename V>  bool decode(V& v)
66158                 {
66159                         clear();
66160                         if(!v(ref_nested())) return false;
66161                         if(equal(reject)) { type = 1; return true; }
66162                         else if(equal(reject)) { type = 2; return true; }
66163                         else if(equal(reject)) { type = 3; return true; }
66164                         else if(equal(reject)) { type = 4; return true; }
66165                         else if(equal(ignore)) { type = 5; return true; }
66166                         else if(equal(ignore)) { type = 6; return true; }
66167                         else { type = 7; return true;}
66168                         return false;
66169
66170                 }
66171                 template<typename V> bool encode(V& v) const
66172                 {
66173                         return v(ref_nested());
66174
66175                 }
66176                 protected:
66177                 template<typename V>  bool decode(size_t index, V& v)
66178                 {
66179                         clear();
66180                         switch(index)
66181                         {
66182                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66183                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
66184                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
66185                         case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
66186                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
66187                         case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
66188                         case 7: type = 7; return v(ref_nested());
66189                         ref_nested().clear();
66190                         }
66191                         return false;
66192
66193                 }
66194                 template<typename V> bool encode(size_t index, V& v) const
66195                 {
66196                         if(index != type) {return false;} return v(ref_nested());
66197
66198                 }
66199                 private:
66200                 size_t type {0};
66201
66202         };
66203         struct Value_t : asn::typefield<true>
66204         {
66205                 ~Value_t()      {clear();}
66206                 size_t get_index() const {return type;}
66207                 UE_X2AP_ID& select_id_Old_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(1); }
66208                 UE_X2AP_ID const* get_id_Old_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(1); }
66209                 UE_X2AP_ID& select_id_New_eNB_UE_X2AP_ID() { return set<UE_X2AP_ID>(2); }
66210                 UE_X2AP_ID const* get_id_New_eNB_UE_X2AP_ID() const { return get<UE_X2AP_ID>(2); }
66211                 UE_X2AP_ID_Extension& select_id_Old_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(3); }
66212                 UE_X2AP_ID_Extension const* get_id_Old_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(3); }
66213                 UE_X2AP_ID_Extension& select_id_New_eNB_UE_X2AP_ID_Extension() { return set<UE_X2AP_ID_Extension>(4); }
66214                 UE_X2AP_ID_Extension const* get_id_New_eNB_UE_X2AP_ID_Extension() const { return get<UE_X2AP_ID_Extension>(4); }
66215                 SIPTOBearerDeactivationIndication& select_id_SIPTO_BearerDeactivationIndication() { return set<SIPTOBearerDeactivationIndication>(5); }
66216                 SIPTOBearerDeactivationIndication const* get_id_SIPTO_BearerDeactivationIndication() const { return get<SIPTOBearerDeactivationIndication>(5); }
66217                 SgNB_UE_X2AP_ID& select_id_SgNB_UE_X2AP_ID() { return set<SgNB_UE_X2AP_ID>(6); }
66218                 SgNB_UE_X2AP_ID const* get_id_SgNB_UE_X2AP_ID() const { return get<SgNB_UE_X2AP_ID>(6); }
66219                 bool is_unknown() const { return type == 7; }
66220                 void clear()
66221                 {
66222                         switch(type)
66223                         {
66224                         case 1: var.destroy<UE_X2AP_ID>(); break;
66225                         case 2: var.destroy<UE_X2AP_ID>(); break;
66226                         case 3: var.destroy<UE_X2AP_ID_Extension>(); break;
66227                         case 4: var.destroy<UE_X2AP_ID_Extension>(); break;
66228                         case 5: var.destroy<SIPTOBearerDeactivationIndication>(); break;
66229                         case 6: var.destroy<SgNB_UE_X2AP_ID>(); break;
66230                         }
66231                         type = 0; ref_nested().clear();
66232                 }
66233                 template<typename V> static inline void enumerate(V& v)
66234                 {
66235                         v.template operator()<UE_X2AP_ID>(1);
66236                         v.template operator()<UE_X2AP_ID>(2);
66237                         v.template operator()<UE_X2AP_ID_Extension>(3);
66238                         v.template operator()<UE_X2AP_ID_Extension>(4);
66239                         v.template operator()<SIPTOBearerDeactivationIndication>(5);
66240                         v.template operator()<SgNB_UE_X2AP_ID>(6);
66241
66242                 }
66243                 protected:
66244                 template<typename V> bool decode(size_t index, V& v)
66245                 {
66246                         clear();
66247                         switch(index)
66248                         {
66249                         case 1: v(select_id_Old_eNB_UE_X2AP_ID()); return true;
66250                         case 2: v(select_id_New_eNB_UE_X2AP_ID()); return true;
66251                         case 3: v(select_id_Old_eNB_UE_X2AP_ID_Extension()); return true;
66252                         case 4: v(select_id_New_eNB_UE_X2AP_ID_Extension()); return true;
66253                         case 5: v(select_id_SIPTO_BearerDeactivationIndication()); return true;
66254                         case 6: v(select_id_SgNB_UE_X2AP_ID()); return true;
66255                         case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
66256                         }
66257                         return false;
66258
66259                 }
66260                 template<typename V> bool encode(size_t index, V& v) const
66261                 {
66262                         if(index != type) return false;
66263                         switch(type)
66264                         {
66265                         case 1: v(var.as<UE_X2AP_ID>()); return true;
66266                         case 2: v(var.as<UE_X2AP_ID>()); return true;
66267                         case 3: v(var.as<UE_X2AP_ID_Extension>()); return true;
66268                         case 4: v(var.as<UE_X2AP_ID_Extension>()); return true;
66269                         case 5: v(var.as<SIPTOBearerDeactivationIndication>()); return true;
66270                         case 6: v(var.as<SgNB_UE_X2AP_ID>()); return true;
66271                         }
66272                         return false;
66273
66274                 }
66275                 private:
66276                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66277                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66278                 union union_type
66279                 {
66280                         char dummy1[sizeof(SIPTOBearerDeactivationIndication)];
66281                         char dummy2[sizeof(SgNB_UE_X2AP_ID)];
66282                         char dummy3[sizeof(UE_X2AP_ID)];
66283                         char dummy4[sizeof(UE_X2AP_ID_Extension)];
66284
66285                 };
66286                 asn::variant<sizeof(union_type)> var;
66287                 size_t type {0};
66288
66289         };
66290         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66291         {
66292                 size_t get_index() const {return type;}
66293                 bool is_unknown() const { return type == 7; }
66294                 void clear() {type = 0;}
66295                 void select_id_Old_eNB_UE_X2AP_ID() { set(mandatory); type=1;}
66296                 void select_id_New_eNB_UE_X2AP_ID() { set(mandatory); type=2;}
66297                 void select_id_Old_eNB_UE_X2AP_ID_Extension() { set(optional); type=3;}
66298                 void select_id_New_eNB_UE_X2AP_ID_Extension() { set(optional); type=4;}
66299                 void select_id_SIPTO_BearerDeactivationIndication() { set(optional); type=5;}
66300                 void select_id_SgNB_UE_X2AP_ID() { set(optional); type=6;}
66301                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66302                 template<typename V>  bool decode(V& v)
66303                 {
66304                         clear();
66305                         if(!v(ref_nested())) return false;
66306                         if(equal(mandatory)) { type = 1; return true; }
66307                         else if(equal(mandatory)) { type = 2; return true; }
66308                         else if(equal(optional)) { type = 3; return true; }
66309                         else if(equal(optional)) { type = 4; return true; }
66310                         else if(equal(optional)) { type = 5; return true; }
66311                         else if(equal(optional)) { type = 6; return true; }
66312                         else { type = 7; return true;}
66313                         return false;
66314
66315                 }
66316                 template<typename V> bool encode(V& v) const
66317                 {
66318                         return v(ref_nested());
66319
66320                 }
66321                 protected:
66322                 template<typename V>  bool decode(size_t index, V& v)
66323                 {
66324                         clear();
66325                         switch(index)
66326                         {
66327                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66328                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
66329                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
66330                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
66331                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
66332                         case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
66333                         case 7: type = 7; return v(ref_nested());
66334                         ref_nested().clear();
66335                         }
66336                         return false;
66337
66338                 }
66339                 template<typename V> bool encode(size_t index, V& v) const
66340                 {
66341                         if(index != type) {return false;} return v(ref_nested());
66342
66343                 }
66344                 private:
66345                 size_t type {0};
66346
66347         };
66348
66349 };
66350 /*
66351 UEContextRelease ::= SEQUENCE {
66352         protocolIEs             ProtocolIE-Container    {{UEContextRelease-IEs}},
66353         ...
66354 }
66355 */
66356
66357 struct UEContextRelease : asn::sequence<1, 0, true, 0>
66358 {
66359         static constexpr const char* name() {return "UEContextRelease";}
66360         using parent_t = asn::sequence<1, 0, true, 0>;
66361         struct protocolIEs_t : ProtocolIE_Container<UEContextRelease_IEs>
66362         {
66363                 static constexpr const char* name() {return "protocolIEs_t";}
66364                 using parent_t = ProtocolIE_Container<UEContextRelease_IEs>;
66365
66366         };
66367         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66368         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66369         template<typename V> void decode(V& v)
66370         {
66371                 v(protocolIEs);
66372
66373         };
66374         template<typename V> void encode(V& v) const
66375         {
66376                 v(protocolIEs);
66377
66378         };
66379         void clear()
66380         {
66381                 protocolIEs.clear();
66382
66383         };
66384         private:
66385         protocolIEs_t   protocolIEs;
66386
66387 };
66388 /*
66389 X2AP-Message ::= OCTET STRING
66390 */
66391
66392 struct X2AP_Message : asn::ostring<>
66393 {
66394         static constexpr const char* name() {return "X2AP-Message";}
66395         using parent_t = asn::ostring<>;
66396
66397 };
66398
66399 /*
66400 X2APMessageTransfer-IEs X2AP-PROTOCOL-IES ::= {
66401         { ID id-RNL-Header      CRITICALITY reject      TYPE RNL-Header                         PRESENCE mandatory}|
66402         { ID id-x2APMessage     CRITICALITY reject      TYPE X2AP-Message                       PRESENCE optional},
66403         ...
66404 }
66405 */
66406
66407 struct X2APMessageTransfer_IEs
66408 {
66409         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66410         {
66411                 size_t get_index() const {return type;}
66412                 bool is_unknown() const { return type == 3; }
66413                 void clear() {type = 0;}
66414                 void select_id_RNL_Header() { set(id_RNL_Header); type=1;}
66415                 void select_id_x2APMessage() { set(id_x2APMessage); type=2;}
66416                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66417                 template<typename V>  bool decode(V& v)
66418                 {
66419                         clear();
66420                         if(!v(ref_nested())) return false;
66421                         if(equal(id_RNL_Header)) { type = 1; return true; }
66422                         else if(equal(id_x2APMessage)) { type = 2; return true; }
66423                         else { type = 3; return true;}
66424                         return false;
66425
66426                 }
66427                 template<typename V> bool encode(V& v) const
66428                 {
66429                         return v(ref_nested());
66430
66431                 }
66432                 protected:
66433                 template<typename V>  bool decode(size_t index, V& v)
66434                 {
66435                         clear();
66436                         switch(index)
66437                         {
66438                         case 1: type = 1; if(v(ref_nested())) { return equal(id_RNL_Header);} return false;
66439                         case 2: type = 2; if(v(ref_nested())) { return equal(id_x2APMessage);} return false;
66440                         case 3: type = 3; return v(ref_nested());
66441                         ref_nested().clear();
66442                         }
66443                         return false;
66444
66445                 }
66446                 template<typename V> bool encode(size_t index, V& v) const
66447                 {
66448                         if(index != type) {return false;} return v(ref_nested());
66449
66450                 }
66451                 private:
66452                 size_t type {0};
66453
66454         };
66455         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66456         {
66457                 size_t get_index() const {return type;}
66458                 bool is_unknown() const { return type == 3; }
66459                 void clear() {type = 0;}
66460                 void select_id_RNL_Header() { set(reject); type=1;}
66461                 void select_id_x2APMessage() { set(reject); type=2;}
66462                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66463                 template<typename V>  bool decode(V& v)
66464                 {
66465                         clear();
66466                         if(!v(ref_nested())) return false;
66467                         if(equal(reject)) { type = 1; return true; }
66468                         else if(equal(reject)) { type = 2; return true; }
66469                         else { type = 3; return true;}
66470                         return false;
66471
66472                 }
66473                 template<typename V> bool encode(V& v) const
66474                 {
66475                         return v(ref_nested());
66476
66477                 }
66478                 protected:
66479                 template<typename V>  bool decode(size_t index, V& v)
66480                 {
66481                         clear();
66482                         switch(index)
66483                         {
66484                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66485                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
66486                         case 3: type = 3; return v(ref_nested());
66487                         ref_nested().clear();
66488                         }
66489                         return false;
66490
66491                 }
66492                 template<typename V> bool encode(size_t index, V& v) const
66493                 {
66494                         if(index != type) {return false;} return v(ref_nested());
66495
66496                 }
66497                 private:
66498                 size_t type {0};
66499
66500         };
66501         struct Value_t : asn::typefield<true>
66502         {
66503                 ~Value_t()      {clear();}
66504                 size_t get_index() const {return type;}
66505                 RNL_Header& select_id_RNL_Header() { return set<RNL_Header>(1); }
66506                 RNL_Header const* get_id_RNL_Header() const { return get<RNL_Header>(1); }
66507                 X2AP_Message& select_id_x2APMessage() { return set<X2AP_Message>(2); }
66508                 X2AP_Message const* get_id_x2APMessage() const { return get<X2AP_Message>(2); }
66509                 bool is_unknown() const { return type == 3; }
66510                 void clear()
66511                 {
66512                         switch(type)
66513                         {
66514                         case 1: var.destroy<RNL_Header>(); break;
66515                         case 2: var.destroy<X2AP_Message>(); break;
66516                         }
66517                         type = 0; ref_nested().clear();
66518                 }
66519                 template<typename V> static inline void enumerate(V& v)
66520                 {
66521                         v.template operator()<RNL_Header>(1);
66522                         v.template operator()<X2AP_Message>(2);
66523
66524                 }
66525                 protected:
66526                 template<typename V> bool decode(size_t index, V& v)
66527                 {
66528                         clear();
66529                         switch(index)
66530                         {
66531                         case 1: v(select_id_RNL_Header()); return true;
66532                         case 2: v(select_id_x2APMessage()); return true;
66533                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
66534                         }
66535                         return false;
66536
66537                 }
66538                 template<typename V> bool encode(size_t index, V& v) const
66539                 {
66540                         if(index != type) return false;
66541                         switch(type)
66542                         {
66543                         case 1: v(var.as<RNL_Header>()); return true;
66544                         case 2: v(var.as<X2AP_Message>()); return true;
66545                         }
66546                         return false;
66547
66548                 }
66549                 private:
66550                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66551                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66552                 union union_type
66553                 {
66554                         char dummy1[sizeof(RNL_Header)];
66555                         char dummy2[sizeof(X2AP_Message)];
66556
66557                 };
66558                 asn::variant<sizeof(union_type)> var;
66559                 size_t type {0};
66560
66561         };
66562         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66563         {
66564                 size_t get_index() const {return type;}
66565                 bool is_unknown() const { return type == 3; }
66566                 void clear() {type = 0;}
66567                 void select_id_RNL_Header() { set(mandatory); type=1;}
66568                 void select_id_x2APMessage() { set(optional); type=2;}
66569                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66570                 template<typename V>  bool decode(V& v)
66571                 {
66572                         clear();
66573                         if(!v(ref_nested())) return false;
66574                         if(equal(mandatory)) { type = 1; return true; }
66575                         else if(equal(optional)) { type = 2; return true; }
66576                         else { type = 3; return true;}
66577                         return false;
66578
66579                 }
66580                 template<typename V> bool encode(V& v) const
66581                 {
66582                         return v(ref_nested());
66583
66584                 }
66585                 protected:
66586                 template<typename V>  bool decode(size_t index, V& v)
66587                 {
66588                         clear();
66589                         switch(index)
66590                         {
66591                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66592                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
66593                         case 3: type = 3; return v(ref_nested());
66594                         ref_nested().clear();
66595                         }
66596                         return false;
66597
66598                 }
66599                 template<typename V> bool encode(size_t index, V& v) const
66600                 {
66601                         if(index != type) {return false;} return v(ref_nested());
66602
66603                 }
66604                 private:
66605                 size_t type {0};
66606
66607         };
66608
66609 };
66610 /*
66611 X2APMessageTransfer ::= SEQUENCE {
66612         protocolIEs             ProtocolIE-Container    {{X2APMessageTransfer-IEs}},
66613         ...
66614 }
66615 */
66616
66617 struct X2APMessageTransfer : asn::sequence<1, 0, true, 0>
66618 {
66619         static constexpr const char* name() {return "X2APMessageTransfer";}
66620         using parent_t = asn::sequence<1, 0, true, 0>;
66621         struct protocolIEs_t : ProtocolIE_Container<X2APMessageTransfer_IEs>
66622         {
66623                 static constexpr const char* name() {return "protocolIEs_t";}
66624                 using parent_t = ProtocolIE_Container<X2APMessageTransfer_IEs>;
66625
66626         };
66627         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66628         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66629         template<typename V> void decode(V& v)
66630         {
66631                 v(protocolIEs);
66632
66633         };
66634         template<typename V> void encode(V& v) const
66635         {
66636                 v(protocolIEs);
66637
66638         };
66639         void clear()
66640         {
66641                 protocolIEs.clear();
66642
66643         };
66644         private:
66645         protocolIEs_t   protocolIEs;
66646
66647 };
66648 /*
66649 X2Release-IEs X2AP-PROTOCOL-IES ::= {
66650         { ID id-GlobalENB-ID                    CRITICALITY reject      TYPE GlobalENB-ID                       PRESENCE mandatory},
66651 ...
66652 }
66653 */
66654
66655 struct X2Release_IEs
66656 {
66657         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66658         {
66659                 size_t get_index() const {return type;}
66660                 bool is_unknown() const { return type == 2; }
66661                 void clear() {type = 0;}
66662                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
66663                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66664                 template<typename V>  bool decode(V& v)
66665                 {
66666                         clear();
66667                         if(!v(ref_nested())) return false;
66668                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
66669                         else { type = 2; return true;}
66670                         return false;
66671
66672                 }
66673                 template<typename V> bool encode(V& v) const
66674                 {
66675                         return v(ref_nested());
66676
66677                 }
66678                 protected:
66679                 template<typename V>  bool decode(size_t index, V& v)
66680                 {
66681                         clear();
66682                         switch(index)
66683                         {
66684                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
66685                         case 2: type = 2; return v(ref_nested());
66686                         ref_nested().clear();
66687                         }
66688                         return false;
66689
66690                 }
66691                 template<typename V> bool encode(size_t index, V& v) const
66692                 {
66693                         if(index != type) {return false;} return v(ref_nested());
66694
66695                 }
66696                 private:
66697                 size_t type {0};
66698
66699         };
66700         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66701         {
66702                 size_t get_index() const {return type;}
66703                 bool is_unknown() const { return type == 2; }
66704                 void clear() {type = 0;}
66705                 void select_id_GlobalENB_ID() { set(reject); type=1;}
66706                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66707                 template<typename V>  bool decode(V& v)
66708                 {
66709                         clear();
66710                         if(!v(ref_nested())) return false;
66711                         if(equal(reject)) { type = 1; return true; }
66712                         else { type = 2; return true;}
66713                         return false;
66714
66715                 }
66716                 template<typename V> bool encode(V& v) const
66717                 {
66718                         return v(ref_nested());
66719
66720                 }
66721                 protected:
66722                 template<typename V>  bool decode(size_t index, V& v)
66723                 {
66724                         clear();
66725                         switch(index)
66726                         {
66727                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
66728                         case 2: type = 2; return v(ref_nested());
66729                         ref_nested().clear();
66730                         }
66731                         return false;
66732
66733                 }
66734                 template<typename V> bool encode(size_t index, V& v) const
66735                 {
66736                         if(index != type) {return false;} return v(ref_nested());
66737
66738                 }
66739                 private:
66740                 size_t type {0};
66741
66742         };
66743         struct Value_t : asn::typefield<true>
66744         {
66745                 ~Value_t()      {clear();}
66746                 size_t get_index() const {return type;}
66747                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
66748                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
66749                 bool is_unknown() const { return type == 2; }
66750                 void clear()
66751                 {
66752                         switch(type)
66753                         {
66754                         case 1: var.destroy<GlobalENB_ID>(); break;
66755                         }
66756                         type = 0; ref_nested().clear();
66757                 }
66758                 template<typename V> static inline void enumerate(V& v)
66759                 {
66760                         v.template operator()<GlobalENB_ID>(1);
66761
66762                 }
66763                 protected:
66764                 template<typename V> bool decode(size_t index, V& v)
66765                 {
66766                         clear();
66767                         switch(index)
66768                         {
66769                         case 1: v(select_id_GlobalENB_ID()); return true;
66770                         case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
66771                         }
66772                         return false;
66773
66774                 }
66775                 template<typename V> bool encode(size_t index, V& v) const
66776                 {
66777                         if(index != type) return false;
66778                         switch(type)
66779                         {
66780                         case 1: v(var.as<GlobalENB_ID>()); return true;
66781                         }
66782                         return false;
66783
66784                 }
66785                 private:
66786                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
66787                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
66788                 union union_type
66789                 {
66790                         char dummy1[sizeof(GlobalENB_ID)];
66791
66792                 };
66793                 asn::variant<sizeof(union_type)> var;
66794                 size_t type {0};
66795
66796         };
66797         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
66798         {
66799                 size_t get_index() const {return type;}
66800                 bool is_unknown() const { return type == 2; }
66801                 void clear() {type = 0;}
66802                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
66803                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
66804                 template<typename V>  bool decode(V& v)
66805                 {
66806                         clear();
66807                         if(!v(ref_nested())) return false;
66808                         if(equal(mandatory)) { type = 1; return true; }
66809                         else { type = 2; return true;}
66810                         return false;
66811
66812                 }
66813                 template<typename V> bool encode(V& v) const
66814                 {
66815                         return v(ref_nested());
66816
66817                 }
66818                 protected:
66819                 template<typename V>  bool decode(size_t index, V& v)
66820                 {
66821                         clear();
66822                         switch(index)
66823                         {
66824                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
66825                         case 2: type = 2; return v(ref_nested());
66826                         ref_nested().clear();
66827                         }
66828                         return false;
66829
66830                 }
66831                 template<typename V> bool encode(size_t index, V& v) const
66832                 {
66833                         if(index != type) {return false;} return v(ref_nested());
66834
66835                 }
66836                 private:
66837                 size_t type {0};
66838
66839         };
66840
66841 };
66842 /*
66843 X2Release ::= SEQUENCE {
66844         protocolIEs             ProtocolIE-Container    {{X2Release-IEs}},
66845         ...
66846 }
66847 */
66848
66849 struct X2Release : asn::sequence<1, 0, true, 0>
66850 {
66851         static constexpr const char* name() {return "X2Release";}
66852         using parent_t = asn::sequence<1, 0, true, 0>;
66853         struct protocolIEs_t : ProtocolIE_Container<X2Release_IEs>
66854         {
66855                 static constexpr const char* name() {return "protocolIEs_t";}
66856                 using parent_t = ProtocolIE_Container<X2Release_IEs>;
66857
66858         };
66859         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
66860         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
66861         template<typename V> void decode(V& v)
66862         {
66863                 v(protocolIEs);
66864
66865         };
66866         template<typename V> void encode(V& v) const
66867         {
66868                 v(protocolIEs);
66869
66870         };
66871         void clear()
66872         {
66873                 protocolIEs.clear();
66874
66875         };
66876         private:
66877         protocolIEs_t   protocolIEs;
66878
66879 };
66880 /*
66881 X2RemovalFailure-IEs X2AP-PROTOCOL-IES ::= {
66882         { ID id-Cause                                           CRITICALITY ignore      TYPE Cause                                                      PRESENCE mandatory}|
66883         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics                     PRESENCE optional},
66884         ...
66885 }
66886 */
66887
66888 struct X2RemovalFailure_IEs
66889 {
66890         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
66891         {
66892                 size_t get_index() const {return type;}
66893                 bool is_unknown() const { return type == 3; }
66894                 void clear() {type = 0;}
66895                 void select_id_Cause() { set(id_Cause); type=1;}
66896                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
66897                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
66898                 template<typename V>  bool decode(V& v)
66899                 {
66900                         clear();
66901                         if(!v(ref_nested())) return false;
66902                         if(equal(id_Cause)) { type = 1; return true; }
66903                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
66904                         else { type = 3; return true;}
66905                         return false;
66906
66907                 }
66908                 template<typename V> bool encode(V& v) const
66909                 {
66910                         return v(ref_nested());
66911
66912                 }
66913                 protected:
66914                 template<typename V>  bool decode(size_t index, V& v)
66915                 {
66916                         clear();
66917                         switch(index)
66918                         {
66919                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
66920                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
66921                         case 3: type = 3; return v(ref_nested());
66922                         ref_nested().clear();
66923                         }
66924                         return false;
66925
66926                 }
66927                 template<typename V> bool encode(size_t index, V& v) const
66928                 {
66929                         if(index != type) {return false;} return v(ref_nested());
66930
66931                 }
66932                 private:
66933                 size_t type {0};
66934
66935         };
66936         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
66937         {
66938                 size_t get_index() const {return type;}
66939                 bool is_unknown() const { return type == 3; }
66940                 void clear() {type = 0;}
66941                 void select_id_Cause() { set(ignore); type=1;}
66942                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
66943                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
66944                 template<typename V>  bool decode(V& v)
66945                 {
66946                         clear();
66947                         if(!v(ref_nested())) return false;
66948                         if(equal(ignore)) { type = 1; return true; }
66949                         else if(equal(ignore)) { type = 2; return true; }
66950                         else { type = 3; return true;}
66951                         return false;
66952
66953                 }
66954                 template<typename V> bool encode(V& v) const
66955                 {
66956                         return v(ref_nested());
66957
66958                 }
66959                 protected:
66960                 template<typename V>  bool decode(size_t index, V& v)
66961                 {
66962                         clear();
66963                         switch(index)
66964                         {
66965                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
66966                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
66967                         case 3: type = 3; return v(ref_nested());
66968                         ref_nested().clear();
66969                         }
66970                         return false;
66971
66972                 }
66973                 template<typename V> bool encode(size_t index, V& v) const
66974                 {
66975                         if(index != type) {return false;} return v(ref_nested());
66976
66977                 }
66978                 private:
66979                 size_t type {0};
66980
66981         };
66982         struct Value_t : asn::typefield<true>
66983         {
66984                 ~Value_t()      {clear();}
66985                 size_t get_index() const {return type;}
66986                 Cause& select_id_Cause() { return set<Cause>(1); }
66987                 Cause const* get_id_Cause() const { return get<Cause>(1); }
66988                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
66989                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
66990                 bool is_unknown() const { return type == 3; }
66991                 void clear()
66992                 {
66993                         switch(type)
66994                         {
66995                         case 1: var.destroy<Cause>(); break;
66996                         case 2: var.destroy<CriticalityDiagnostics>(); break;
66997                         }
66998                         type = 0; ref_nested().clear();
66999                 }
67000                 template<typename V> static inline void enumerate(V& v)
67001                 {
67002                         v.template operator()<Cause>(1);
67003                         v.template operator()<CriticalityDiagnostics>(2);
67004
67005                 }
67006                 protected:
67007                 template<typename V> bool decode(size_t index, V& v)
67008                 {
67009                         clear();
67010                         switch(index)
67011                         {
67012                         case 1: v(select_id_Cause()); return true;
67013                         case 2: v(select_id_CriticalityDiagnostics()); return true;
67014                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67015                         }
67016                         return false;
67017
67018                 }
67019                 template<typename V> bool encode(size_t index, V& v) const
67020                 {
67021                         if(index != type) return false;
67022                         switch(type)
67023                         {
67024                         case 1: v(var.as<Cause>()); return true;
67025                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
67026                         }
67027                         return false;
67028
67029                 }
67030                 private:
67031                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67032                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67033                 union union_type
67034                 {
67035                         char dummy1[sizeof(Cause)];
67036                         char dummy2[sizeof(CriticalityDiagnostics)];
67037
67038                 };
67039                 asn::variant<sizeof(union_type)> var;
67040                 size_t type {0};
67041
67042         };
67043         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67044         {
67045                 size_t get_index() const {return type;}
67046                 bool is_unknown() const { return type == 3; }
67047                 void clear() {type = 0;}
67048                 void select_id_Cause() { set(mandatory); type=1;}
67049                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
67050                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67051                 template<typename V>  bool decode(V& v)
67052                 {
67053                         clear();
67054                         if(!v(ref_nested())) return false;
67055                         if(equal(mandatory)) { type = 1; return true; }
67056                         else if(equal(optional)) { type = 2; return true; }
67057                         else { type = 3; return true;}
67058                         return false;
67059
67060                 }
67061                 template<typename V> bool encode(V& v) const
67062                 {
67063                         return v(ref_nested());
67064
67065                 }
67066                 protected:
67067                 template<typename V>  bool decode(size_t index, V& v)
67068                 {
67069                         clear();
67070                         switch(index)
67071                         {
67072                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67073                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67074                         case 3: type = 3; return v(ref_nested());
67075                         ref_nested().clear();
67076                         }
67077                         return false;
67078
67079                 }
67080                 template<typename V> bool encode(size_t index, V& v) const
67081                 {
67082                         if(index != type) {return false;} return v(ref_nested());
67083
67084                 }
67085                 private:
67086                 size_t type {0};
67087
67088         };
67089
67090 };
67091 /*
67092 X2RemovalFailure ::= SEQUENCE {
67093         protocolIEs             ProtocolIE-Container    {{X2RemovalFailure-IEs}},
67094         ...
67095 }
67096 */
67097
67098 struct X2RemovalFailure : asn::sequence<1, 0, true, 0>
67099 {
67100         static constexpr const char* name() {return "X2RemovalFailure";}
67101         using parent_t = asn::sequence<1, 0, true, 0>;
67102         struct protocolIEs_t : ProtocolIE_Container<X2RemovalFailure_IEs>
67103         {
67104                 static constexpr const char* name() {return "protocolIEs_t";}
67105                 using parent_t = ProtocolIE_Container<X2RemovalFailure_IEs>;
67106
67107         };
67108         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67109         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67110         template<typename V> void decode(V& v)
67111         {
67112                 v(protocolIEs);
67113
67114         };
67115         template<typename V> void encode(V& v) const
67116         {
67117                 v(protocolIEs);
67118
67119         };
67120         void clear()
67121         {
67122                 protocolIEs.clear();
67123
67124         };
67125         private:
67126         protocolIEs_t   protocolIEs;
67127
67128 };
67129 /*
67130 X2RemovalRequest-IEs X2AP-PROTOCOL-IES ::= {
67131         { ID id-GlobalENB-ID                            CRITICALITY reject      TYPE GlobalENB-ID                       PRESENCE mandatory}|
67132         { ID id-X2RemovalThreshold                      CRITICALITY reject      TYPE X2BenefitValue                     PRESENCE optional},
67133 ...
67134 }
67135 */
67136
67137 struct X2RemovalRequest_IEs
67138 {
67139         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67140         {
67141                 size_t get_index() const {return type;}
67142                 bool is_unknown() const { return type == 3; }
67143                 void clear() {type = 0;}
67144                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67145                 void select_id_X2RemovalThreshold() { set(id_X2RemovalThreshold); type=2;}
67146                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67147                 template<typename V>  bool decode(V& v)
67148                 {
67149                         clear();
67150                         if(!v(ref_nested())) return false;
67151                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67152                         else if(equal(id_X2RemovalThreshold)) { type = 2; return true; }
67153                         else { type = 3; return true;}
67154                         return false;
67155
67156                 }
67157                 template<typename V> bool encode(V& v) const
67158                 {
67159                         return v(ref_nested());
67160
67161                 }
67162                 protected:
67163                 template<typename V>  bool decode(size_t index, V& v)
67164                 {
67165                         clear();
67166                         switch(index)
67167                         {
67168                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67169                         case 2: type = 2; if(v(ref_nested())) { return equal(id_X2RemovalThreshold);} return false;
67170                         case 3: type = 3; return v(ref_nested());
67171                         ref_nested().clear();
67172                         }
67173                         return false;
67174
67175                 }
67176                 template<typename V> bool encode(size_t index, V& v) const
67177                 {
67178                         if(index != type) {return false;} return v(ref_nested());
67179
67180                 }
67181                 private:
67182                 size_t type {0};
67183
67184         };
67185         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67186         {
67187                 size_t get_index() const {return type;}
67188                 bool is_unknown() const { return type == 3; }
67189                 void clear() {type = 0;}
67190                 void select_id_GlobalENB_ID() { set(reject); type=1;}
67191                 void select_id_X2RemovalThreshold() { set(reject); type=2;}
67192                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67193                 template<typename V>  bool decode(V& v)
67194                 {
67195                         clear();
67196                         if(!v(ref_nested())) return false;
67197                         if(equal(reject)) { type = 1; return true; }
67198                         else if(equal(reject)) { type = 2; return true; }
67199                         else { type = 3; return true;}
67200                         return false;
67201
67202                 }
67203                 template<typename V> bool encode(V& v) const
67204                 {
67205                         return v(ref_nested());
67206
67207                 }
67208                 protected:
67209                 template<typename V>  bool decode(size_t index, V& v)
67210                 {
67211                         clear();
67212                         switch(index)
67213                         {
67214                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67215                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
67216                         case 3: type = 3; return v(ref_nested());
67217                         ref_nested().clear();
67218                         }
67219                         return false;
67220
67221                 }
67222                 template<typename V> bool encode(size_t index, V& v) const
67223                 {
67224                         if(index != type) {return false;} return v(ref_nested());
67225
67226                 }
67227                 private:
67228                 size_t type {0};
67229
67230         };
67231         struct Value_t : asn::typefield<true>
67232         {
67233                 ~Value_t()      {clear();}
67234                 size_t get_index() const {return type;}
67235                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
67236                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
67237                 X2BenefitValue& select_id_X2RemovalThreshold() { return set<X2BenefitValue>(2); }
67238                 X2BenefitValue const* get_id_X2RemovalThreshold() const { return get<X2BenefitValue>(2); }
67239                 bool is_unknown() const { return type == 3; }
67240                 void clear()
67241                 {
67242                         switch(type)
67243                         {
67244                         case 1: var.destroy<GlobalENB_ID>(); break;
67245                         case 2: var.destroy<X2BenefitValue>(); break;
67246                         }
67247                         type = 0; ref_nested().clear();
67248                 }
67249                 template<typename V> static inline void enumerate(V& v)
67250                 {
67251                         v.template operator()<GlobalENB_ID>(1);
67252                         v.template operator()<X2BenefitValue>(2);
67253
67254                 }
67255                 protected:
67256                 template<typename V> bool decode(size_t index, V& v)
67257                 {
67258                         clear();
67259                         switch(index)
67260                         {
67261                         case 1: v(select_id_GlobalENB_ID()); return true;
67262                         case 2: v(select_id_X2RemovalThreshold()); return true;
67263                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67264                         }
67265                         return false;
67266
67267                 }
67268                 template<typename V> bool encode(size_t index, V& v) const
67269                 {
67270                         if(index != type) return false;
67271                         switch(type)
67272                         {
67273                         case 1: v(var.as<GlobalENB_ID>()); return true;
67274                         case 2: v(var.as<X2BenefitValue>()); return true;
67275                         }
67276                         return false;
67277
67278                 }
67279                 private:
67280                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67281                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67282                 union union_type
67283                 {
67284                         char dummy1[sizeof(GlobalENB_ID)];
67285                         char dummy2[sizeof(X2BenefitValue)];
67286
67287                 };
67288                 asn::variant<sizeof(union_type)> var;
67289                 size_t type {0};
67290
67291         };
67292         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67293         {
67294                 size_t get_index() const {return type;}
67295                 bool is_unknown() const { return type == 3; }
67296                 void clear() {type = 0;}
67297                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
67298                 void select_id_X2RemovalThreshold() { set(optional); type=2;}
67299                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67300                 template<typename V>  bool decode(V& v)
67301                 {
67302                         clear();
67303                         if(!v(ref_nested())) return false;
67304                         if(equal(mandatory)) { type = 1; return true; }
67305                         else if(equal(optional)) { type = 2; return true; }
67306                         else { type = 3; return true;}
67307                         return false;
67308
67309                 }
67310                 template<typename V> bool encode(V& v) const
67311                 {
67312                         return v(ref_nested());
67313
67314                 }
67315                 protected:
67316                 template<typename V>  bool decode(size_t index, V& v)
67317                 {
67318                         clear();
67319                         switch(index)
67320                         {
67321                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67322                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67323                         case 3: type = 3; return v(ref_nested());
67324                         ref_nested().clear();
67325                         }
67326                         return false;
67327
67328                 }
67329                 template<typename V> bool encode(size_t index, V& v) const
67330                 {
67331                         if(index != type) {return false;} return v(ref_nested());
67332
67333                 }
67334                 private:
67335                 size_t type {0};
67336
67337         };
67338
67339 };
67340 /*
67341 X2RemovalRequest ::= SEQUENCE {
67342         protocolIEs             ProtocolIE-Container    {{X2RemovalRequest-IEs}},
67343         ...
67344 }
67345 */
67346
67347 struct X2RemovalRequest : asn::sequence<1, 0, true, 0>
67348 {
67349         static constexpr const char* name() {return "X2RemovalRequest";}
67350         using parent_t = asn::sequence<1, 0, true, 0>;
67351         struct protocolIEs_t : ProtocolIE_Container<X2RemovalRequest_IEs>
67352         {
67353                 static constexpr const char* name() {return "protocolIEs_t";}
67354                 using parent_t = ProtocolIE_Container<X2RemovalRequest_IEs>;
67355
67356         };
67357         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67358         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67359         template<typename V> void decode(V& v)
67360         {
67361                 v(protocolIEs);
67362
67363         };
67364         template<typename V> void encode(V& v) const
67365         {
67366                 v(protocolIEs);
67367
67368         };
67369         void clear()
67370         {
67371                 protocolIEs.clear();
67372
67373         };
67374         private:
67375         protocolIEs_t   protocolIEs;
67376
67377 };
67378 /*
67379 X2RemovalResponse-IEs X2AP-PROTOCOL-IES ::= {
67380         { ID id-GlobalENB-ID                            CRITICALITY reject      TYPE GlobalENB-ID                               PRESENCE mandatory}|
67381         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics             PRESENCE optional},
67382         ...
67383 }
67384 */
67385
67386 struct X2RemovalResponse_IEs
67387 {
67388         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67389         {
67390                 size_t get_index() const {return type;}
67391                 bool is_unknown() const { return type == 3; }
67392                 void clear() {type = 0;}
67393                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67394                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=2;}
67395                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67396                 template<typename V>  bool decode(V& v)
67397                 {
67398                         clear();
67399                         if(!v(ref_nested())) return false;
67400                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67401                         else if(equal(id_CriticalityDiagnostics)) { type = 2; return true; }
67402                         else { type = 3; return true;}
67403                         return false;
67404
67405                 }
67406                 template<typename V> bool encode(V& v) const
67407                 {
67408                         return v(ref_nested());
67409
67410                 }
67411                 protected:
67412                 template<typename V>  bool decode(size_t index, V& v)
67413                 {
67414                         clear();
67415                         switch(index)
67416                         {
67417                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67418                         case 2: type = 2; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
67419                         case 3: type = 3; return v(ref_nested());
67420                         ref_nested().clear();
67421                         }
67422                         return false;
67423
67424                 }
67425                 template<typename V> bool encode(size_t index, V& v) const
67426                 {
67427                         if(index != type) {return false;} return v(ref_nested());
67428
67429                 }
67430                 private:
67431                 size_t type {0};
67432
67433         };
67434         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67435         {
67436                 size_t get_index() const {return type;}
67437                 bool is_unknown() const { return type == 3; }
67438                 void clear() {type = 0;}
67439                 void select_id_GlobalENB_ID() { set(reject); type=1;}
67440                 void select_id_CriticalityDiagnostics() { set(ignore); type=2;}
67441                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67442                 template<typename V>  bool decode(V& v)
67443                 {
67444                         clear();
67445                         if(!v(ref_nested())) return false;
67446                         if(equal(reject)) { type = 1; return true; }
67447                         else if(equal(ignore)) { type = 2; return true; }
67448                         else { type = 3; return true;}
67449                         return false;
67450
67451                 }
67452                 template<typename V> bool encode(V& v) const
67453                 {
67454                         return v(ref_nested());
67455
67456                 }
67457                 protected:
67458                 template<typename V>  bool decode(size_t index, V& v)
67459                 {
67460                         clear();
67461                         switch(index)
67462                         {
67463                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67464                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
67465                         case 3: type = 3; return v(ref_nested());
67466                         ref_nested().clear();
67467                         }
67468                         return false;
67469
67470                 }
67471                 template<typename V> bool encode(size_t index, V& v) const
67472                 {
67473                         if(index != type) {return false;} return v(ref_nested());
67474
67475                 }
67476                 private:
67477                 size_t type {0};
67478
67479         };
67480         struct Value_t : asn::typefield<true>
67481         {
67482                 ~Value_t()      {clear();}
67483                 size_t get_index() const {return type;}
67484                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
67485                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
67486                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(2); }
67487                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(2); }
67488                 bool is_unknown() const { return type == 3; }
67489                 void clear()
67490                 {
67491                         switch(type)
67492                         {
67493                         case 1: var.destroy<GlobalENB_ID>(); break;
67494                         case 2: var.destroy<CriticalityDiagnostics>(); break;
67495                         }
67496                         type = 0; ref_nested().clear();
67497                 }
67498                 template<typename V> static inline void enumerate(V& v)
67499                 {
67500                         v.template operator()<GlobalENB_ID>(1);
67501                         v.template operator()<CriticalityDiagnostics>(2);
67502
67503                 }
67504                 protected:
67505                 template<typename V> bool decode(size_t index, V& v)
67506                 {
67507                         clear();
67508                         switch(index)
67509                         {
67510                         case 1: v(select_id_GlobalENB_ID()); return true;
67511                         case 2: v(select_id_CriticalityDiagnostics()); return true;
67512                         case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
67513                         }
67514                         return false;
67515
67516                 }
67517                 template<typename V> bool encode(size_t index, V& v) const
67518                 {
67519                         if(index != type) return false;
67520                         switch(type)
67521                         {
67522                         case 1: v(var.as<GlobalENB_ID>()); return true;
67523                         case 2: v(var.as<CriticalityDiagnostics>()); return true;
67524                         }
67525                         return false;
67526
67527                 }
67528                 private:
67529                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67530                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67531                 union union_type
67532                 {
67533                         char dummy1[sizeof(CriticalityDiagnostics)];
67534                         char dummy2[sizeof(GlobalENB_ID)];
67535
67536                 };
67537                 asn::variant<sizeof(union_type)> var;
67538                 size_t type {0};
67539
67540         };
67541         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67542         {
67543                 size_t get_index() const {return type;}
67544                 bool is_unknown() const { return type == 3; }
67545                 void clear() {type = 0;}
67546                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
67547                 void select_id_CriticalityDiagnostics() { set(optional); type=2;}
67548                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67549                 template<typename V>  bool decode(V& v)
67550                 {
67551                         clear();
67552                         if(!v(ref_nested())) return false;
67553                         if(equal(mandatory)) { type = 1; return true; }
67554                         else if(equal(optional)) { type = 2; return true; }
67555                         else { type = 3; return true;}
67556                         return false;
67557
67558                 }
67559                 template<typename V> bool encode(V& v) const
67560                 {
67561                         return v(ref_nested());
67562
67563                 }
67564                 protected:
67565                 template<typename V>  bool decode(size_t index, V& v)
67566                 {
67567                         clear();
67568                         switch(index)
67569                         {
67570                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67571                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67572                         case 3: type = 3; return v(ref_nested());
67573                         ref_nested().clear();
67574                         }
67575                         return false;
67576
67577                 }
67578                 template<typename V> bool encode(size_t index, V& v) const
67579                 {
67580                         if(index != type) {return false;} return v(ref_nested());
67581
67582                 }
67583                 private:
67584                 size_t type {0};
67585
67586         };
67587
67588 };
67589 /*
67590 X2RemovalResponse ::= SEQUENCE {
67591         protocolIEs             ProtocolIE-Container    {{X2RemovalResponse-IEs}},
67592         ...
67593 }
67594 */
67595
67596 struct X2RemovalResponse : asn::sequence<1, 0, true, 0>
67597 {
67598         static constexpr const char* name() {return "X2RemovalResponse";}
67599         using parent_t = asn::sequence<1, 0, true, 0>;
67600         struct protocolIEs_t : ProtocolIE_Container<X2RemovalResponse_IEs>
67601         {
67602                 static constexpr const char* name() {return "protocolIEs_t";}
67603                 using parent_t = ProtocolIE_Container<X2RemovalResponse_IEs>;
67604
67605         };
67606         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67607         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67608         template<typename V> void decode(V& v)
67609         {
67610                 v(protocolIEs);
67611
67612         };
67613         template<typename V> void encode(V& v) const
67614         {
67615                 v(protocolIEs);
67616
67617         };
67618         void clear()
67619         {
67620                 protocolIEs.clear();
67621
67622         };
67623         private:
67624         protocolIEs_t   protocolIEs;
67625
67626 };
67627 /*
67628 X2SetupFailure-IEs X2AP-PROTOCOL-IES ::= {
67629         { ID id-Cause                                   CRITICALITY ignore              TYPE Cause                                                              PRESENCE mandatory} |
67630         { ID id-TimeToWait                              CRITICALITY ignore              TYPE TimeToWait                                                 PRESENCE optional} |
67631         { ID id-CriticalityDiagnostics  CRITICALITY ignore              TYPE CriticalityDiagnostics                             PRESENCE optional },
67632
67633         ...
67634 }
67635 */
67636
67637 struct X2SetupFailure_IEs
67638 {
67639         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67640         {
67641                 size_t get_index() const {return type;}
67642                 bool is_unknown() const { return type == 4; }
67643                 void clear() {type = 0;}
67644                 void select_id_Cause() { set(id_Cause); type=1;}
67645                 void select_id_TimeToWait() { set(id_TimeToWait); type=2;}
67646                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=3;}
67647                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67648                 template<typename V>  bool decode(V& v)
67649                 {
67650                         clear();
67651                         if(!v(ref_nested())) return false;
67652                         if(equal(id_Cause)) { type = 1; return true; }
67653                         else if(equal(id_TimeToWait)) { type = 2; return true; }
67654                         else if(equal(id_CriticalityDiagnostics)) { type = 3; return true; }
67655                         else { type = 4; return true;}
67656                         return false;
67657
67658                 }
67659                 template<typename V> bool encode(V& v) const
67660                 {
67661                         return v(ref_nested());
67662
67663                 }
67664                 protected:
67665                 template<typename V>  bool decode(size_t index, V& v)
67666                 {
67667                         clear();
67668                         switch(index)
67669                         {
67670                         case 1: type = 1; if(v(ref_nested())) { return equal(id_Cause);} return false;
67671                         case 2: type = 2; if(v(ref_nested())) { return equal(id_TimeToWait);} return false;
67672                         case 3: type = 3; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
67673                         case 4: type = 4; return v(ref_nested());
67674                         ref_nested().clear();
67675                         }
67676                         return false;
67677
67678                 }
67679                 template<typename V> bool encode(size_t index, V& v) const
67680                 {
67681                         if(index != type) {return false;} return v(ref_nested());
67682
67683                 }
67684                 private:
67685                 size_t type {0};
67686
67687         };
67688         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67689         {
67690                 size_t get_index() const {return type;}
67691                 bool is_unknown() const { return type == 4; }
67692                 void clear() {type = 0;}
67693                 void select_id_Cause() { set(ignore); type=1;}
67694                 void select_id_TimeToWait() { set(ignore); type=2;}
67695                 void select_id_CriticalityDiagnostics() { set(ignore); type=3;}
67696                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67697                 template<typename V>  bool decode(V& v)
67698                 {
67699                         clear();
67700                         if(!v(ref_nested())) return false;
67701                         if(equal(ignore)) { type = 1; return true; }
67702                         else if(equal(ignore)) { type = 2; return true; }
67703                         else if(equal(ignore)) { type = 3; return true; }
67704                         else { type = 4; return true;}
67705                         return false;
67706
67707                 }
67708                 template<typename V> bool encode(V& v) const
67709                 {
67710                         return v(ref_nested());
67711
67712                 }
67713                 protected:
67714                 template<typename V>  bool decode(size_t index, V& v)
67715                 {
67716                         clear();
67717                         switch(index)
67718                         {
67719                         case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
67720                         case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
67721                         case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
67722                         case 4: type = 4; return v(ref_nested());
67723                         ref_nested().clear();
67724                         }
67725                         return false;
67726
67727                 }
67728                 template<typename V> bool encode(size_t index, V& v) const
67729                 {
67730                         if(index != type) {return false;} return v(ref_nested());
67731
67732                 }
67733                 private:
67734                 size_t type {0};
67735
67736         };
67737         struct Value_t : asn::typefield<true>
67738         {
67739                 ~Value_t()      {clear();}
67740                 size_t get_index() const {return type;}
67741                 Cause& select_id_Cause() { return set<Cause>(1); }
67742                 Cause const* get_id_Cause() const { return get<Cause>(1); }
67743                 TimeToWait& select_id_TimeToWait() { return set<TimeToWait>(2); }
67744                 TimeToWait const* get_id_TimeToWait() const { return get<TimeToWait>(2); }
67745                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(3); }
67746                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(3); }
67747                 bool is_unknown() const { return type == 4; }
67748                 void clear()
67749                 {
67750                         switch(type)
67751                         {
67752                         case 1: var.destroy<Cause>(); break;
67753                         case 2: var.destroy<TimeToWait>(); break;
67754                         case 3: var.destroy<CriticalityDiagnostics>(); break;
67755                         }
67756                         type = 0; ref_nested().clear();
67757                 }
67758                 template<typename V> static inline void enumerate(V& v)
67759                 {
67760                         v.template operator()<Cause>(1);
67761                         v.template operator()<TimeToWait>(2);
67762                         v.template operator()<CriticalityDiagnostics>(3);
67763
67764                 }
67765                 protected:
67766                 template<typename V> bool decode(size_t index, V& v)
67767                 {
67768                         clear();
67769                         switch(index)
67770                         {
67771                         case 1: v(select_id_Cause()); return true;
67772                         case 2: v(select_id_TimeToWait()); return true;
67773                         case 3: v(select_id_CriticalityDiagnostics()); return true;
67774                         case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
67775                         }
67776                         return false;
67777
67778                 }
67779                 template<typename V> bool encode(size_t index, V& v) const
67780                 {
67781                         if(index != type) return false;
67782                         switch(type)
67783                         {
67784                         case 1: v(var.as<Cause>()); return true;
67785                         case 2: v(var.as<TimeToWait>()); return true;
67786                         case 3: v(var.as<CriticalityDiagnostics>()); return true;
67787                         }
67788                         return false;
67789
67790                 }
67791                 private:
67792                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
67793                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
67794                 union union_type
67795                 {
67796                         char dummy1[sizeof(Cause)];
67797                         char dummy2[sizeof(CriticalityDiagnostics)];
67798                         char dummy3[sizeof(TimeToWait)];
67799
67800                 };
67801                 asn::variant<sizeof(union_type)> var;
67802                 size_t type {0};
67803
67804         };
67805         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
67806         {
67807                 size_t get_index() const {return type;}
67808                 bool is_unknown() const { return type == 4; }
67809                 void clear() {type = 0;}
67810                 void select_id_Cause() { set(mandatory); type=1;}
67811                 void select_id_TimeToWait() { set(optional); type=2;}
67812                 void select_id_CriticalityDiagnostics() { set(optional); type=3;}
67813                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
67814                 template<typename V>  bool decode(V& v)
67815                 {
67816                         clear();
67817                         if(!v(ref_nested())) return false;
67818                         if(equal(mandatory)) { type = 1; return true; }
67819                         else if(equal(optional)) { type = 2; return true; }
67820                         else if(equal(optional)) { type = 3; return true; }
67821                         else { type = 4; return true;}
67822                         return false;
67823
67824                 }
67825                 template<typename V> bool encode(V& v) const
67826                 {
67827                         return v(ref_nested());
67828
67829                 }
67830                 protected:
67831                 template<typename V>  bool decode(size_t index, V& v)
67832                 {
67833                         clear();
67834                         switch(index)
67835                         {
67836                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
67837                         case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
67838                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
67839                         case 4: type = 4; return v(ref_nested());
67840                         ref_nested().clear();
67841                         }
67842                         return false;
67843
67844                 }
67845                 template<typename V> bool encode(size_t index, V& v) const
67846                 {
67847                         if(index != type) {return false;} return v(ref_nested());
67848
67849                 }
67850                 private:
67851                 size_t type {0};
67852
67853         };
67854
67855 };
67856 /*
67857 X2SetupFailure ::= SEQUENCE {
67858         protocolIEs             ProtocolIE-Container    {{X2SetupFailure-IEs}},
67859         ...
67860 }
67861 */
67862
67863 struct X2SetupFailure : asn::sequence<1, 0, true, 0>
67864 {
67865         static constexpr const char* name() {return "X2SetupFailure";}
67866         using parent_t = asn::sequence<1, 0, true, 0>;
67867         struct protocolIEs_t : ProtocolIE_Container<X2SetupFailure_IEs>
67868         {
67869                 static constexpr const char* name() {return "protocolIEs_t";}
67870                 using parent_t = ProtocolIE_Container<X2SetupFailure_IEs>;
67871
67872         };
67873         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
67874         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
67875         template<typename V> void decode(V& v)
67876         {
67877                 v(protocolIEs);
67878
67879         };
67880         template<typename V> void encode(V& v) const
67881         {
67882                 v(protocolIEs);
67883
67884         };
67885         void clear()
67886         {
67887                 protocolIEs.clear();
67888
67889         };
67890         private:
67891         protocolIEs_t   protocolIEs;
67892
67893 };
67894 /*
67895 X2SetupRequest-IEs X2AP-PROTOCOL-IES ::= {
67896         { ID id-GlobalENB-ID                    CRITICALITY reject      TYPE GlobalENB-ID                       PRESENCE mandatory}|
67897         { ID id-ServedCells                             CRITICALITY reject      TYPE ServedCells                        PRESENCE mandatory}|
67898         { ID id-GUGroupIDList                   CRITICALITY reject      TYPE GUGroupIDList                      PRESENCE optional}|
67899         { ID id-LHN-ID                                  CRITICALITY ignore      TYPE LHN-ID                                     PRESENCE optional},
67900 ...
67901 }
67902 */
67903
67904 struct X2SetupRequest_IEs
67905 {
67906         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
67907         {
67908                 size_t get_index() const {return type;}
67909                 bool is_unknown() const { return type == 5; }
67910                 void clear() {type = 0;}
67911                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
67912                 void select_id_ServedCells() { set(id_ServedCells); type=2;}
67913                 void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
67914                 void select_id_LHN_ID() { set(id_LHN_ID); type=4;}
67915                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
67916                 template<typename V>  bool decode(V& v)
67917                 {
67918                         clear();
67919                         if(!v(ref_nested())) return false;
67920                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
67921                         else if(equal(id_ServedCells)) { type = 2; return true; }
67922                         else if(equal(id_GUGroupIDList)) { type = 3; return true; }
67923                         else if(equal(id_LHN_ID)) { type = 4; return true; }
67924                         else { type = 5; return true;}
67925                         return false;
67926
67927                 }
67928                 template<typename V> bool encode(V& v) const
67929                 {
67930                         return v(ref_nested());
67931
67932                 }
67933                 protected:
67934                 template<typename V>  bool decode(size_t index, V& v)
67935                 {
67936                         clear();
67937                         switch(index)
67938                         {
67939                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
67940                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
67941                         case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
67942                         case 4: type = 4; if(v(ref_nested())) { return equal(id_LHN_ID);} return false;
67943                         case 5: type = 5; return v(ref_nested());
67944                         ref_nested().clear();
67945                         }
67946                         return false;
67947
67948                 }
67949                 template<typename V> bool encode(size_t index, V& v) const
67950                 {
67951                         if(index != type) {return false;} return v(ref_nested());
67952
67953                 }
67954                 private:
67955                 size_t type {0};
67956
67957         };
67958         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
67959         {
67960                 size_t get_index() const {return type;}
67961                 bool is_unknown() const { return type == 5; }
67962                 void clear() {type = 0;}
67963                 void select_id_GlobalENB_ID() { set(reject); type=1;}
67964                 void select_id_ServedCells() { set(reject); type=2;}
67965                 void select_id_GUGroupIDList() { set(reject); type=3;}
67966                 void select_id_LHN_ID() { set(ignore); type=4;}
67967                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
67968                 template<typename V>  bool decode(V& v)
67969                 {
67970                         clear();
67971                         if(!v(ref_nested())) return false;
67972                         if(equal(reject)) { type = 1; return true; }
67973                         else if(equal(reject)) { type = 2; return true; }
67974                         else if(equal(reject)) { type = 3; return true; }
67975                         else if(equal(ignore)) { type = 4; return true; }
67976                         else { type = 5; return true;}
67977                         return false;
67978
67979                 }
67980                 template<typename V> bool encode(V& v) const
67981                 {
67982                         return v(ref_nested());
67983
67984                 }
67985                 protected:
67986                 template<typename V>  bool decode(size_t index, V& v)
67987                 {
67988                         clear();
67989                         switch(index)
67990                         {
67991                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
67992                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
67993                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
67994                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
67995                         case 5: type = 5; return v(ref_nested());
67996                         ref_nested().clear();
67997                         }
67998                         return false;
67999
68000                 }
68001                 template<typename V> bool encode(size_t index, V& v) const
68002                 {
68003                         if(index != type) {return false;} return v(ref_nested());
68004
68005                 }
68006                 private:
68007                 size_t type {0};
68008
68009         };
68010         struct Value_t : asn::typefield<true>
68011         {
68012                 ~Value_t()      {clear();}
68013                 size_t get_index() const {return type;}
68014                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
68015                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
68016                 ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
68017                 ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
68018                 GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
68019                 GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
68020                 LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(4); }
68021                 LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(4); }
68022                 bool is_unknown() const { return type == 5; }
68023                 void clear()
68024                 {
68025                         switch(type)
68026                         {
68027                         case 1: var.destroy<GlobalENB_ID>(); break;
68028                         case 2: var.destroy<ServedCells>(); break;
68029                         case 3: var.destroy<GUGroupIDList>(); break;
68030                         case 4: var.destroy<LHN_ID>(); break;
68031                         }
68032                         type = 0; ref_nested().clear();
68033                 }
68034                 template<typename V> static inline void enumerate(V& v)
68035                 {
68036                         v.template operator()<GlobalENB_ID>(1);
68037                         v.template operator()<ServedCells>(2);
68038                         v.template operator()<GUGroupIDList>(3);
68039                         v.template operator()<LHN_ID>(4);
68040
68041                 }
68042                 protected:
68043                 template<typename V> bool decode(size_t index, V& v)
68044                 {
68045                         clear();
68046                         switch(index)
68047                         {
68048                         case 1: v(select_id_GlobalENB_ID()); return true;
68049                         case 2: v(select_id_ServedCells()); return true;
68050                         case 3: v(select_id_GUGroupIDList()); return true;
68051                         case 4: v(select_id_LHN_ID()); return true;
68052                         case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
68053                         }
68054                         return false;
68055
68056                 }
68057                 template<typename V> bool encode(size_t index, V& v) const
68058                 {
68059                         if(index != type) return false;
68060                         switch(type)
68061                         {
68062                         case 1: v(var.as<GlobalENB_ID>()); return true;
68063                         case 2: v(var.as<ServedCells>()); return true;
68064                         case 3: v(var.as<GUGroupIDList>()); return true;
68065                         case 4: v(var.as<LHN_ID>()); return true;
68066                         }
68067                         return false;
68068
68069                 }
68070                 private:
68071                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
68072                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
68073                 union union_type
68074                 {
68075                         char dummy1[sizeof(GUGroupIDList)];
68076                         char dummy2[sizeof(GlobalENB_ID)];
68077                         char dummy3[sizeof(LHN_ID)];
68078                         char dummy4[sizeof(ServedCells)];
68079
68080                 };
68081                 asn::variant<sizeof(union_type)> var;
68082                 size_t type {0};
68083
68084         };
68085         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
68086         {
68087                 size_t get_index() const {return type;}
68088                 bool is_unknown() const { return type == 5; }
68089                 void clear() {type = 0;}
68090                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
68091                 void select_id_ServedCells() { set(mandatory); type=2;}
68092                 void select_id_GUGroupIDList() { set(optional); type=3;}
68093                 void select_id_LHN_ID() { set(optional); type=4;}
68094                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
68095                 template<typename V>  bool decode(V& v)
68096                 {
68097                         clear();
68098                         if(!v(ref_nested())) return false;
68099                         if(equal(mandatory)) { type = 1; return true; }
68100                         else if(equal(mandatory)) { type = 2; return true; }
68101                         else if(equal(optional)) { type = 3; return true; }
68102                         else if(equal(optional)) { type = 4; return true; }
68103                         else { type = 5; return true;}
68104                         return false;
68105
68106                 }
68107                 template<typename V> bool encode(V& v) const
68108                 {
68109                         return v(ref_nested());
68110
68111                 }
68112                 protected:
68113                 template<typename V>  bool decode(size_t index, V& v)
68114                 {
68115                         clear();
68116                         switch(index)
68117                         {
68118                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
68119                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
68120                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
68121                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
68122                         case 5: type = 5; return v(ref_nested());
68123                         ref_nested().clear();
68124                         }
68125                         return false;
68126
68127                 }
68128                 template<typename V> bool encode(size_t index, V& v) const
68129                 {
68130                         if(index != type) {return false;} return v(ref_nested());
68131
68132                 }
68133                 private:
68134                 size_t type {0};
68135
68136         };
68137
68138 };
68139 /*
68140 X2SetupRequest ::= SEQUENCE {
68141         protocolIEs             ProtocolIE-Container    {{X2SetupRequest-IEs}},
68142         ...
68143 }
68144 */
68145
68146 struct X2SetupRequest : asn::sequence<1, 0, true, 0>
68147 {
68148         static constexpr const char* name() {return "X2SetupRequest";}
68149         using parent_t = asn::sequence<1, 0, true, 0>;
68150         struct protocolIEs_t : ProtocolIE_Container<X2SetupRequest_IEs>
68151         {
68152                 static constexpr const char* name() {return "protocolIEs_t";}
68153                 using parent_t = ProtocolIE_Container<X2SetupRequest_IEs>;
68154
68155         };
68156         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
68157         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
68158         template<typename V> void decode(V& v)
68159         {
68160                 v(protocolIEs);
68161
68162         };
68163         template<typename V> void encode(V& v) const
68164         {
68165                 v(protocolIEs);
68166
68167         };
68168         void clear()
68169         {
68170                 protocolIEs.clear();
68171
68172         };
68173         private:
68174         protocolIEs_t   protocolIEs;
68175
68176 };
68177 /*
68178 X2SetupResponse-IEs X2AP-PROTOCOL-IES ::= {
68179         { ID id-GlobalENB-ID                            CRITICALITY reject      TYPE GlobalENB-ID                       PRESENCE mandatory}|
68180         { ID id-ServedCells                                     CRITICALITY reject      TYPE ServedCells                        PRESENCE mandatory}|
68181         { ID id-GUGroupIDList                           CRITICALITY reject      TYPE GUGroupIDList                      PRESENCE optional}|
68182         { ID id-CriticalityDiagnostics          CRITICALITY ignore      TYPE CriticalityDiagnostics     PRESENCE optional}|
68183         { ID id-LHN-ID                                          CRITICALITY ignore      TYPE LHN-ID                                     PRESENCE optional},
68184         ...
68185 }
68186 */
68187
68188 struct X2SetupResponse_IEs
68189 {
68190         struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
68191         {
68192                 size_t get_index() const {return type;}
68193                 bool is_unknown() const { return type == 6; }
68194                 void clear() {type = 0;}
68195                 void select_id_GlobalENB_ID() { set(id_GlobalENB_ID); type=1;}
68196                 void select_id_ServedCells() { set(id_ServedCells); type=2;}
68197                 void select_id_GUGroupIDList() { set(id_GUGroupIDList); type=3;}
68198                 void select_id_CriticalityDiagnostics() { set(id_CriticalityDiagnostics); type=4;}
68199                 void select_id_LHN_ID() { set(id_LHN_ID); type=5;}
68200                 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
68201                 template<typename V>  bool decode(V& v)
68202                 {
68203                         clear();
68204                         if(!v(ref_nested())) return false;
68205                         if(equal(id_GlobalENB_ID)) { type = 1; return true; }
68206                         else if(equal(id_ServedCells)) { type = 2; return true; }
68207                         else if(equal(id_GUGroupIDList)) { type = 3; return true; }
68208                         else if(equal(id_CriticalityDiagnostics)) { type = 4; return true; }
68209                         else if(equal(id_LHN_ID)) { type = 5; return true; }
68210                         else { type = 6; return true;}
68211                         return false;
68212
68213                 }
68214                 template<typename V> bool encode(V& v) const
68215                 {
68216                         return v(ref_nested());
68217
68218                 }
68219                 protected:
68220                 template<typename V>  bool decode(size_t index, V& v)
68221                 {
68222                         clear();
68223                         switch(index)
68224                         {
68225                         case 1: type = 1; if(v(ref_nested())) { return equal(id_GlobalENB_ID);} return false;
68226                         case 2: type = 2; if(v(ref_nested())) { return equal(id_ServedCells);} return false;
68227                         case 3: type = 3; if(v(ref_nested())) { return equal(id_GUGroupIDList);} return false;
68228                         case 4: type = 4; if(v(ref_nested())) { return equal(id_CriticalityDiagnostics);} return false;
68229                         case 5: type = 5; if(v(ref_nested())) { return equal(id_LHN_ID);} return false;
68230                         case 6: type = 6; return v(ref_nested());
68231                         ref_nested().clear();
68232                         }
68233                         return false;
68234
68235                 }
68236                 template<typename V> bool encode(size_t index, V& v) const
68237                 {
68238                         if(index != type) {return false;} return v(ref_nested());
68239
68240                 }
68241                 private:
68242                 size_t type {0};
68243
68244         };
68245         struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
68246         {
68247                 size_t get_index() const {return type;}
68248                 bool is_unknown() const { return type == 6; }
68249                 void clear() {type = 0;}
68250                 void select_id_GlobalENB_ID() { set(reject); type=1;}
68251                 void select_id_ServedCells() { set(reject); type=2;}
68252                 void select_id_GUGroupIDList() { set(reject); type=3;}
68253                 void select_id_CriticalityDiagnostics() { set(ignore); type=4;}
68254                 void select_id_LHN_ID() { set(ignore); type=5;}
68255                 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
68256                 template<typename V>  bool decode(V& v)
68257                 {
68258                         clear();
68259                         if(!v(ref_nested())) return false;
68260                         if(equal(reject)) { type = 1; return true; }
68261                         else if(equal(reject)) { type = 2; return true; }
68262                         else if(equal(reject)) { type = 3; return true; }
68263                         else if(equal(ignore)) { type = 4; return true; }
68264                         else if(equal(ignore)) { type = 5; return true; }
68265                         else { type = 6; return true;}
68266                         return false;
68267
68268                 }
68269                 template<typename V> bool encode(V& v) const
68270                 {
68271                         return v(ref_nested());
68272
68273                 }
68274                 protected:
68275                 template<typename V>  bool decode(size_t index, V& v)
68276                 {
68277                         clear();
68278                         switch(index)
68279                         {
68280                         case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
68281                         case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
68282                         case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
68283                         case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
68284                         case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
68285                         case 6: type = 6; return v(ref_nested());
68286                         ref_nested().clear();
68287                         }
68288                         return false;
68289
68290                 }
68291                 template<typename V> bool encode(size_t index, V& v) const
68292                 {
68293                         if(index != type) {return false;} return v(ref_nested());
68294
68295                 }
68296                 private:
68297                 size_t type {0};
68298
68299         };
68300         struct Value_t : asn::typefield<true>
68301         {
68302                 ~Value_t()      {clear();}
68303                 size_t get_index() const {return type;}
68304                 GlobalENB_ID& select_id_GlobalENB_ID() { return set<GlobalENB_ID>(1); }
68305                 GlobalENB_ID const* get_id_GlobalENB_ID() const { return get<GlobalENB_ID>(1); }
68306                 ServedCells& select_id_ServedCells() { return set<ServedCells>(2); }
68307                 ServedCells const* get_id_ServedCells() const { return get<ServedCells>(2); }
68308                 GUGroupIDList& select_id_GUGroupIDList() { return set<GUGroupIDList>(3); }
68309                 GUGroupIDList const* get_id_GUGroupIDList() const { return get<GUGroupIDList>(3); }
68310                 CriticalityDiagnostics& select_id_CriticalityDiagnostics() { return set<CriticalityDiagnostics>(4); }
68311                 CriticalityDiagnostics const* get_id_CriticalityDiagnostics() const { return get<CriticalityDiagnostics>(4); }
68312                 LHN_ID& select_id_LHN_ID() { return set<LHN_ID>(5); }
68313                 LHN_ID const* get_id_LHN_ID() const { return get<LHN_ID>(5); }
68314                 bool is_unknown() const { return type == 6; }
68315                 void clear()
68316                 {
68317                         switch(type)
68318                         {
68319                         case 1: var.destroy<GlobalENB_ID>(); break;
68320                         case 2: var.destroy<ServedCells>(); break;
68321                         case 3: var.destroy<GUGroupIDList>(); break;
68322                         case 4: var.destroy<CriticalityDiagnostics>(); break;
68323                         case 5: var.destroy<LHN_ID>(); break;
68324                         }
68325                         type = 0; ref_nested().clear();
68326                 }
68327                 template<typename V> static inline void enumerate(V& v)
68328                 {
68329                         v.template operator()<GlobalENB_ID>(1);
68330                         v.template operator()<ServedCells>(2);
68331                         v.template operator()<GUGroupIDList>(3);
68332                         v.template operator()<CriticalityDiagnostics>(4);
68333                         v.template operator()<LHN_ID>(5);
68334
68335                 }
68336                 protected:
68337                 template<typename V> bool decode(size_t index, V& v)
68338                 {
68339                         clear();
68340                         switch(index)
68341                         {
68342                         case 1: v(select_id_GlobalENB_ID()); return true;
68343                         case 2: v(select_id_ServedCells()); return true;
68344                         case 3: v(select_id_GUGroupIDList()); return true;
68345                         case 4: v(select_id_CriticalityDiagnostics()); return true;
68346                         case 5: v(select_id_LHN_ID()); return true;
68347                         case 6: if(type != 6) {clear(); asn::base::set();} type = 6; return true;
68348                         }
68349                         return false;
68350
68351                 }
68352                 template<typename V> bool encode(size_t index, V& v) const
68353                 {
68354                         if(index != type) return false;
68355                         switch(type)
68356                         {
68357                         case 1: v(var.as<GlobalENB_ID>()); return true;
68358                         case 2: v(var.as<ServedCells>()); return true;
68359                         case 3: v(var.as<GUGroupIDList>()); return true;
68360                         case 4: v(var.as<CriticalityDiagnostics>()); return true;
68361                         case 5: v(var.as<LHN_ID>()); return true;
68362                         }
68363                         return false;
68364
68365                 }
68366                 private:
68367                 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
68368                 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
68369                 union union_type
68370                 {
68371                         char dummy1[sizeof(CriticalityDiagnostics)];
68372                         char dummy2[sizeof(GUGroupIDList)];
68373                         char dummy3[sizeof(GlobalENB_ID)];
68374                         char dummy4[sizeof(LHN_ID)];
68375                         char dummy5[sizeof(ServedCells)];
68376
68377                 };
68378                 asn::variant<sizeof(union_type)> var;
68379                 size_t type {0};
68380
68381         };
68382         struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
68383         {
68384                 size_t get_index() const {return type;}
68385                 bool is_unknown() const { return type == 6; }
68386                 void clear() {type = 0;}
68387                 void select_id_GlobalENB_ID() { set(mandatory); type=1;}
68388                 void select_id_ServedCells() { set(mandatory); type=2;}
68389                 void select_id_GUGroupIDList() { set(optional); type=3;}
68390                 void select_id_CriticalityDiagnostics() { set(optional); type=4;}
68391                 void select_id_LHN_ID() { set(optional); type=5;}
68392                 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
68393                 template<typename V>  bool decode(V& v)
68394                 {
68395                         clear();
68396                         if(!v(ref_nested())) return false;
68397                         if(equal(mandatory)) { type = 1; return true; }
68398                         else if(equal(mandatory)) { type = 2; return true; }
68399                         else if(equal(optional)) { type = 3; return true; }
68400                         else if(equal(optional)) { type = 4; return true; }
68401                         else if(equal(optional)) { type = 5; return true; }
68402                         else { type = 6; return true;}
68403                         return false;
68404
68405                 }
68406                 template<typename V> bool encode(V& v) const
68407                 {
68408                         return v(ref_nested());
68409
68410                 }
68411                 protected:
68412                 template<typename V>  bool decode(size_t index, V& v)
68413                 {
68414                         clear();
68415                         switch(index)
68416                         {
68417                         case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
68418                         case 2: type = 2; if(v(ref_nested())) { return equal(mandatory);} return false;
68419                         case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
68420                         case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
68421                         case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
68422                         case 6: type = 6; return v(ref_nested());
68423                         ref_nested().clear();
68424                         }
68425                         return false;
68426
68427                 }
68428                 template<typename V> bool encode(size_t index, V& v) const
68429                 {
68430                         if(index != type) {return false;} return v(ref_nested());
68431
68432                 }
68433                 private:
68434                 size_t type {0};
68435
68436         };
68437
68438 };
68439 /*
68440 X2SetupResponse ::= SEQUENCE {
68441         protocolIEs             ProtocolIE-Container    {{X2SetupResponse-IEs}},
68442         ...
68443 }
68444 */
68445
68446 struct X2SetupResponse : asn::sequence<1, 0, true, 0>
68447 {
68448         static constexpr const char* name() {return "X2SetupResponse";}
68449         using parent_t = asn::sequence<1, 0, true, 0>;
68450         struct protocolIEs_t : ProtocolIE_Container<X2SetupResponse_IEs>
68451         {
68452                 static constexpr const char* name() {return "protocolIEs_t";}
68453                 using parent_t = ProtocolIE_Container<X2SetupResponse_IEs>;
68454
68455         };
68456         protocolIEs_t& ref_protocolIEs() {return protocolIEs;}
68457         protocolIEs_t const& ref_protocolIEs() const {return protocolIEs;}
68458         template<typename V> void decode(V& v)
68459         {
68460                 v(protocolIEs);
68461
68462         };
68463         template<typename V> void encode(V& v) const
68464         {
68465                 v(protocolIEs);
68466
68467         };
68468         void clear()
68469         {
68470                 protocolIEs.clear();
68471
68472         };
68473         private:
68474         protocolIEs_t   protocolIEs;
68475
68476 };