Reorganize directories and switch libaries to using asn1c
[it/test.git] / simulators / e2sim / src / ASN1 / generated / E2AP-IEs.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
25 /*
26 CauseRIC ::= ENUMERATED {
27         function-id-Invalid,
28         action-not-supported,
29         excessive-actions,
30         duplicate-action,
31         duplicate-event,
32         function-resource-limit,
33         request-id-unknown,
34         inconsistent-action-subsequent-action-sequence,
35         control-message-invalid,
36         call-process-id-invalid,
37         function-not-required,
38         excessive-functions,
39         ric-resource-limit,
40         ...
41 }
42 */
43
44 struct CauseRIC : asn::enumerated<13, 0, true>
45 {
46         static constexpr const char* name() {return "CauseRIC";}
47         using parent_t = asn::enumerated<13, 0, true>;
48         typedef enum {
49                 function_id_Invalid
50                 ,action_not_supported
51                 ,excessive_actions
52                 ,duplicate_action
53                 ,duplicate_event
54                 ,function_resource_limit
55                 ,request_id_unknown
56                 ,inconsistent_action_subsequent_action_sequence
57                 ,control_message_invalid
58                 ,call_process_id_invalid
59                 ,function_not_required
60                 ,excessive_functions
61                 ,ric_resource_limit
62         } index_t;
63
64 };
65
66 /*
67 RANfunctionDefinition ::= OCTET STRING
68 */
69
70 struct RANfunctionDefinition : asn::ostring<>
71 {
72         static constexpr const char* name() {return "RANfunctionDefinition";}
73         using parent_t = asn::ostring<>;
74
75 };
76
77 /*
78 RANfunctionID ::= INTEGER (0..4095)
79 */
80
81 struct RANfunctionID : asn::integer<>
82 {
83         using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
84         static constexpr const char* name() {return "RANfunctionID";}
85         using parent_t = asn::integer<>;
86
87 };
88
89 /*
90 RICactionDefinition ::= OCTET STRING
91 */
92
93 struct RICactionDefinition : asn::ostring<>
94 {
95         static constexpr const char* name() {return "RICactionDefinition";}
96         using parent_t = asn::ostring<>;
97
98 };
99
100 /*
101 RICactionID ::= INTEGER (0..255)
102 */
103
104 struct RICactionID : asn::integer<>
105 {
106         using constraint_t = asn::constraints<false,asn::span<0, 255>>;
107         static constexpr const char* name() {return "RICactionID";}
108         using parent_t = asn::integer<>;
109
110 };
111
112 /*
113 RICactionType ::= ENUMERATED{
114         report,
115         insert,
116         policy,
117         ...
118 }
119 */
120
121 struct RICactionType : asn::enumerated<3, 0, true>
122 {
123         static constexpr const char* name() {return "RICactionType";}
124         using parent_t = asn::enumerated<3, 0, true>;
125         typedef enum {
126                 report
127                 ,insert
128                 ,policy
129         } index_t;
130
131 };
132
133 /*
134 RICcallProcessID ::= OCTET STRING
135 */
136
137 struct RICcallProcessID : asn::ostring<>
138 {
139         static constexpr const char* name() {return "RICcallProcessID";}
140         using parent_t = asn::ostring<>;
141
142 };
143
144 /*
145 RICcause ::= CHOICE {
146         radioNetwork            CauseRadioNetwork,
147         transport                       CauseTransport,
148         protocol                        CauseProtocol,
149         misc                            CauseMisc,
150         ric                                     CauseRIC,
151         ...
152 }
153 */
154
155 struct RICcause : asn::choice<5, 0, true>
156 {
157         static constexpr const char* name() {return "RICcause";}
158         using parent_t = asn::choice<5, 0, true>;
159         index_type get_index() const {return index;}
160         bool is_unknown() const {return index == 6;}
161         void set_unknown() { set_index(6);  }
162         ~RICcause() {clear();}
163         struct radioNetwork_t : CauseRadioNetwork
164         {
165                 static constexpr const char* name() {return "radioNetwork_t";}
166                 using parent_t = CauseRadioNetwork;
167
168         };
169         struct transport_t : CauseTransport
170         {
171                 static constexpr const char* name() {return "transport_t";}
172                 using parent_t = CauseTransport;
173
174         };
175         struct protocol_t : CauseProtocol
176         {
177                 static constexpr const char* name() {return "protocol_t";}
178                 using parent_t = CauseProtocol;
179
180         };
181         struct misc_t : CauseMisc
182         {
183                 static constexpr const char* name() {return "misc_t";}
184                 using parent_t = CauseMisc;
185
186         };
187         struct ric_t : CauseRIC
188         {
189                 static constexpr const char* name() {return "ric_t";}
190                 using parent_t = CauseRIC;
191
192         };
193         void clear()
194         {
195                 switch(get_index())
196                 {
197                 case 1: var.destroy<radioNetwork_t>(); break;
198                 case 2: var.destroy<transport_t>(); break;
199                 case 3: var.destroy<protocol_t>(); break;
200                 case 4: var.destroy<misc_t>(); break;
201                 case 5: var.destroy<ric_t>(); break;
202                 }
203                 index = 0;
204                 base::clear();
205         }
206         template<typename V> bool decode(size_t idx, V& v)
207         {
208                 clear();
209                 switch(idx)
210                 {
211                 case 1: set_index(1); return v(var.build<radioNetwork_t>());
212                 case 2: set_index(2); return v(var.build<transport_t>());
213                 case 3: set_index(3); return v(var.build<protocol_t>());
214                 case 4: set_index(4); return v(var.build<misc_t>());
215                 case 5: set_index(5); return v(var.build<ric_t>());
216                 }
217                 return false;
218
219         }
220         template<typename V> bool encode(V& v) const
221         {
222                 switch(get_index())
223                 {
224                 case 1: return v(var.as<radioNetwork_t>());
225                 case 2: return v(var.as<transport_t>());
226                 case 3: return v(var.as<protocol_t>());
227                 case 4: return v(var.as<misc_t>());
228                 case 5: return v(var.as<ric_t>());
229                 }
230                 return false;
231         }
232         template<typename V> static inline void enumerate(V& v)
233         {
234                 v.template operator()<radioNetwork_t>(1);
235                 v.template operator()<transport_t>(2);
236                 v.template operator()<protocol_t>(3);
237                 v.template operator()<misc_t>(4);
238                 v.template operator()<ric_t>(5);
239
240         }
241         radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
242         radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
243         transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
244         transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
245         protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
246         protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
247         misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
248         misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
249         ric_t& select_ric() { if(get_index() != 5) { clear(); set_index(5); return var.build<ric_t>();} return var.as<ric_t>();}
250         ric_t const* get_ric() const { if(get_index() == 5) { return &var.as<ric_t>();} return nullptr; }
251         private:
252         void set_index(index_type i) {index = i; base::set();}
253         union union_type
254         {
255                 char dummy1[sizeof(radioNetwork_t)];
256                 char dummy2[sizeof(transport_t)];
257                 char dummy3[sizeof(protocol_t)];
258                 char dummy4[sizeof(misc_t)];
259                 char dummy5[sizeof(ric_t)];
260
261         };
262         asn::variant<sizeof(union_type)>        var;
263         index_type      index {0};
264 };
265 /*
266 RICcontrolAckRequest ::= ENUMERATED{
267         noAck,
268         ack,
269         nAck,
270         ...
271 }
272 */
273
274 struct RICcontrolAckRequest : asn::enumerated<3, 0, true>
275 {
276         static constexpr const char* name() {return "RICcontrolAckRequest";}
277         using parent_t = asn::enumerated<3, 0, true>;
278         typedef enum {
279                 noAck
280                 ,ack
281                 ,nAck
282         } index_t;
283
284 };
285
286 /*
287 RICcontrolHeader ::= OCTET STRING
288 */
289
290 struct RICcontrolHeader : asn::ostring<>
291 {
292         static constexpr const char* name() {return "RICcontrolHeader";}
293         using parent_t = asn::ostring<>;
294
295 };
296
297 /*
298 RICcontrolMessage ::= OCTET STRING
299 */
300
301 struct RICcontrolMessage : asn::ostring<>
302 {
303         static constexpr const char* name() {return "RICcontrolMessage";}
304         using parent_t = asn::ostring<>;
305
306 };
307
308 /*
309 RICcontrolStatus ::= ENUMERATED{
310         success,
311         rejected,
312         failed,
313         ...
314 }
315 */
316
317 struct RICcontrolStatus : asn::enumerated<3, 0, true>
318 {
319         static constexpr const char* name() {return "RICcontrolStatus";}
320         using parent_t = asn::enumerated<3, 0, true>;
321         typedef enum {
322                 success
323                 ,rejected
324                 ,failed
325         } index_t;
326
327 };
328
329 /*
330 RICeventTriggerDefinition ::= OCTET STRING
331 */
332
333 struct RICeventTriggerDefinition : asn::ostring<>
334 {
335         static constexpr const char* name() {return "RICeventTriggerDefinition";}
336         using parent_t = asn::ostring<>;
337
338 };
339
340 /*
341 RICindicationHeader ::= OCTET STRING
342 */
343
344 struct RICindicationHeader : asn::ostring<>
345 {
346         static constexpr const char* name() {return "RICindicationHeader";}
347         using parent_t = asn::ostring<>;
348
349 };
350
351 /*
352 RICindicationMessage ::= OCTET STRING
353 */
354
355 struct RICindicationMessage : asn::ostring<>
356 {
357         static constexpr const char* name() {return "RICindicationMessage";}
358         using parent_t = asn::ostring<>;
359
360 };
361
362 /*
363 RICindicationSN ::= INTEGER (0..65535)
364 */
365
366 struct RICindicationSN : asn::integer<>
367 {
368         using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
369         static constexpr const char* name() {return "RICindicationSN";}
370         using parent_t = asn::integer<>;
371
372 };
373
374 /*
375 RICindicationType ::= ENUMERATED{
376         report,
377         insert,
378         ...
379 }
380 */
381
382 struct RICindicationType : asn::enumerated<2, 0, true>
383 {
384         static constexpr const char* name() {return "RICindicationType";}
385         using parent_t = asn::enumerated<2, 0, true>;
386         typedef enum {
387                 report
388                 ,insert
389         } index_t;
390
391 };
392
393 /*
394 RICrequestID ::= SEQUENCE {
395         ricRequestorID                          INTEGER (0..65535),
396         ricRequestSequenceNumber        INTEGER (0..65535),
397         ...
398 }
399 */
400
401 struct RICrequestID : asn::sequence<2, 0, true, 0>
402 {
403         static constexpr const char* name() {return "RICrequestID";}
404         using parent_t = asn::sequence<2, 0, true, 0>;
405         struct ricRequestorID_t : asn::integer<>
406         {
407                 using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
408                 static constexpr const char* name() {return "ricRequestorID_t";}
409                 using parent_t = asn::integer<>;
410
411         };
412
413         ricRequestorID_t& ref_ricRequestorID() {return ricRequestorID;}
414         ricRequestorID_t const& ref_ricRequestorID() const {return ricRequestorID;}
415         struct ricRequestSequenceNumber_t : asn::integer<>
416         {
417                 using constraint_t = asn::constraints<false,asn::span<0, 65535>>;
418                 static constexpr const char* name() {return "ricRequestSequenceNumber_t";}
419                 using parent_t = asn::integer<>;
420
421         };
422
423         ricRequestSequenceNumber_t& ref_ricRequestSequenceNumber() {return ricRequestSequenceNumber;}
424         ricRequestSequenceNumber_t const& ref_ricRequestSequenceNumber() const {return ricRequestSequenceNumber;}
425         template<typename V> void decode(V& v)
426         {
427                 v(ricRequestorID);
428                 v(ricRequestSequenceNumber);
429
430         };
431         template<typename V> void encode(V& v) const
432         {
433                 v(ricRequestorID);
434                 v(ricRequestSequenceNumber);
435
436         };
437         void clear()
438         {
439                 ricRequestorID.clear();
440                 ricRequestSequenceNumber.clear();
441
442         };
443         private:
444         ricRequestorID_t        ricRequestorID;
445         ricRequestSequenceNumber_t      ricRequestSequenceNumber;
446
447 };
448 /*
449 RICsubsequentActionType ::= ENUMERATED{
450         continue,
451         wait,
452         ...
453 }
454 */
455
456 struct RICsubsequentActionType : asn::enumerated<2, 0, true>
457 {
458         static constexpr const char* name() {return "RICsubsequentActionType";}
459         using parent_t = asn::enumerated<2, 0, true>;
460         typedef enum {
461                 Continue
462                 ,wait
463         } index_t;
464
465 };
466
467 /*
468 RICtimeToWait ::= ENUMERATED{
469         zero,
470         w1ms,
471         w2ms,
472         w5ms,
473         w10ms,
474         w20ms,
475         w30ms,
476         w40ms,
477         w50ms,
478         w100ms,
479         w200ms,
480         w500ms,
481         w1s,
482         w2s,
483         w5s,
484         w10s,
485         w20s,
486         w60s,
487         ...
488 }
489 */
490
491 struct RICtimeToWait : asn::enumerated<18, 0, true>
492 {
493         static constexpr const char* name() {return "RICtimeToWait";}
494         using parent_t = asn::enumerated<18, 0, true>;
495         typedef enum {
496                 zero
497                 ,w1ms
498                 ,w2ms
499                 ,w5ms
500                 ,w10ms
501                 ,w20ms
502                 ,w30ms
503                 ,w40ms
504                 ,w50ms
505                 ,w100ms
506                 ,w200ms
507                 ,w500ms
508                 ,w1s
509                 ,w2s
510                 ,w5s
511                 ,w10s
512                 ,w20s
513                 ,w60s
514         } index_t;
515
516 };
517
518 /*
519 RICsubsequentAction ::=SEQUENCE{
520         ricSubsequentActionType         RICsubsequentActionType,
521         ricTimeToWait                           RICtimeToWait,
522         ...
523 }
524 */
525
526 struct RICsubsequentAction : asn::sequence<2, 0, true, 0>
527 {
528         static constexpr const char* name() {return "RICsubsequentAction";}
529         using parent_t = asn::sequence<2, 0, true, 0>;
530         struct ricSubsequentActionType_t : RICsubsequentActionType
531         {
532                 static constexpr const char* name() {return "ricSubsequentActionType_t";}
533                 using parent_t = RICsubsequentActionType;
534
535         };
536         ricSubsequentActionType_t& ref_ricSubsequentActionType() {return ricSubsequentActionType;}
537         ricSubsequentActionType_t const& ref_ricSubsequentActionType() const {return ricSubsequentActionType;}
538         struct ricTimeToWait_t : RICtimeToWait
539         {
540                 static constexpr const char* name() {return "ricTimeToWait_t";}
541                 using parent_t = RICtimeToWait;
542
543         };
544         ricTimeToWait_t& ref_ricTimeToWait() {return ricTimeToWait;}
545         ricTimeToWait_t const& ref_ricTimeToWait() const {return ricTimeToWait;}
546         template<typename V> void decode(V& v)
547         {
548                 v(ricSubsequentActionType);
549                 v(ricTimeToWait);
550
551         };
552         template<typename V> void encode(V& v) const
553         {
554                 v(ricSubsequentActionType);
555                 v(ricTimeToWait);
556
557         };
558         void clear()
559         {
560                 ricSubsequentActionType.clear();
561                 ricTimeToWait.clear();
562
563         };
564         private:
565         ricSubsequentActionType_t       ricSubsequentActionType;
566         ricTimeToWait_t ricTimeToWait;
567
568 };