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